@powersync/service-core 1.21.0 → 1.23.0

package/src/storage/implementation/IncrementalReprocessingSyncConfigLog.ts

@@ -0,0 +1,109 @@
+import { BucketDataSource, ParameterIndexLookupCreator, SyncConfigWithErrors } from '@powersync/service-sync-rules';
+import {
+  IncrementalMappingChanges,
+  IncrementalMappingDefinitionChange,
+  SingleSyncConfigBucketDefinitionMapping
+} from './BucketDefinitionMapping.js';
+
+export interface IncrementalDefinitionLogEntry extends IncrementalMappingDefinitionChange {
+  sourceTables?: string[];
+}
+
+export interface IncrementalSyncConfigUpdateLog {
+  reusedDefinitions: IncrementalDefinitionLogEntry[];
+  addedDefinitions: IncrementalDefinitionLogEntry[];
+  droppedDefinitions: IncrementalDefinitionLogEntry[];
+}
+
+export function formatIncrementalSyncConfigUpdateLog(log: IncrementalSyncConfigUpdateLog) {
+  return [
+    formatDefinitionSection('Reused definitions', log.reusedDefinitions),
+    formatDefinitionSection('New definitions', log.addedDefinitions, { includeSnapshotTables: true }),
+    formatDefinitionSection('Definitions to drop after switching', log.droppedDefinitions)
+  ].join('\n');
+}
+
+export function describeIncrementalSyncConfigUpdate(options: {
+  activeMappings: SingleSyncConfigBucketDefinitionMapping[];
+  newMapping: SingleSyncConfigBucketDefinitionMapping;
+  newSyncConfig: SyncConfigWithErrors;
+  mappingChanges: IncrementalMappingChanges;
+}): IncrementalSyncConfigUpdateLog {
+  const { activeMappings, newMapping, newSyncConfig, mappingChanges } = options;
+  const newDefinitionKeys = new Set(newMapping.allDefinitionEntries().map(definitionKey));
+  const activeDefinitions = uniqueDefinitions(activeMappings.flatMap((mapping) => mapping.allDefinitionEntries()));
+
+  return {
+    reusedDefinitions: mappingChanges.reusedDefinitions,
+    addedDefinitions: mappingChanges.addedDefinitions.map((definition) => {
+      const sourceTables = sourceTablesForDefinition(newSyncConfig, newMapping, definition);
+      return {
+        ...definition,
+        sourceTables
+      };
+    }),
+    droppedDefinitions: activeDefinitions.filter((definition) => !newDefinitionKeys.has(definitionKey(definition)))
+  };
+}
+
+function sourceTablesForDefinition(
+  syncConfig: SyncConfigWithErrors,
+  mapping: SingleSyncConfigBucketDefinitionMapping,
+  definition: IncrementalMappingDefinitionChange
+) {
+  if (definition.type == 'bucket_data') {
+    return sourceTablesForSources(
+      syncConfig.config.bucketDataSources.filter((source) => mapping.bucketSourceId(source) == definition.id)
+    );
+  }
+
+  return sourceTablesForSources(
+    syncConfig.config.bucketParameterLookupSources.filter(
+      (source) => mapping.parameterLookupId(source) == definition.id
+    )
+  );
+}
+
+function sourceTablesForSources(sources: Array<BucketDataSource | ParameterIndexLookupCreator>) {
+  return uniqueSorted(sources.flatMap((source) => [...source.getSourceTables()].map((table) => table.tablePattern)));
+}
+
+function definitionKey(definition: IncrementalMappingDefinitionChange) {
+  return `${definition.type}:${definition.id}`;
+}
+
+function uniqueSorted(values: string[]) {
+  return [...new Set(values)].sort();
+}
+
+function uniqueDefinitions(definitions: IncrementalMappingDefinitionChange[]) {
+  const byKey = new Map<string, IncrementalMappingDefinitionChange>();
+  for (const definition of definitions) {
+    byKey.set(definitionKey(definition), definition);
+  }
+  return [...byKey.values()];
+}
+
+function formatDefinitionSection(
+  title: string,
+  definitions: IncrementalDefinitionLogEntry[],
+  options: { includeSnapshotTables?: boolean } = {}
+) {
+  if (definitions.length == 0) {
+    return `${title}: none`;
+  }
+
+  return [`${title}:`, ...definitions.map((definition) => `  - ${formatDefinition(definition, options)}`)].join('\n');
+}
+
+function formatDefinition(definition: IncrementalDefinitionLogEntry, options: { includeSnapshotTables?: boolean }) {
+  const details = [`type=${definition.type}`, `id=${definition.id}`, `name=${definition.name}`];
+  if (definition.sourceTables != null) {
+    details.push(`tables=${formatList(definition.sourceTables)}`);
+  }
+  return details.join(', ');
+}
+
+function formatList(values: string[]) {
+  return values.length == 0 ? 'none' : values.join(', ');
+}

package/src/storage/implementation/ReplicationStreamStorageIds.ts

@@ -0,0 +1,21 @@
+import { BucketDefinitionId, ParameterIndexId } from '@powersync/service-sync-rules';
+import { SingleSyncConfigBucketDefinitionMapping } from './BucketDefinitionMapping.js';
+
+/**
+ * Persisted storage ids for a replication stream, derived from the rule_mapping documents
+ * of all its sync configs.
+ *
+ * This requires no parsed sync configs, and deliberately does not resolve individual
+ * sources - use the parsed-set-bound {@link BucketDefinitionMapping} for that.
+ */
+export class ReplicationStreamStorageIds {
+  constructor(private readonly mappings: SingleSyncConfigBucketDefinitionMapping[]) {}
+
+  get bucketDefinitionIds(): BucketDefinitionId[] {
+    return [...new Set(this.mappings.flatMap((mapping) => mapping.allBucketDefinitionIds()))];
+  }
+
+  get parameterIndexIds(): ParameterIndexId[] {
+    return [...new Set(this.mappings.flatMap((mapping) => mapping.allParameterIndexIds()))];
+  }
+}

package/src/storage/storage-index.ts

@@ -3,7 +3,10 @@ export * from './BucketStorage.js';
 export * from './BucketStorageBatch.js';
 export * from './BucketStorageFactory.js';
 export * from './ChecksumCache.js';
-export * from './PersistedSyncRulesContent.js';
+export * from './ParsedSyncConfigSet.js';
+export * from './PersistedReplicationStream.js';
+export * from './PersistedSyncConfigContent.js';
+export * from './PersistedSyncConfigStatus.js';
 export * from './ReplicationEventPayload.js';
 export * from './ReplicationLock.js';
 export * from './ReportStorage.js';
@@ -15,3 +18,8 @@ export * from './StorageProvider.js';
 export * from './StorageVersionConfig.js';
 export * from './SyncRulesBucketStorage.js';
 export * from './WriteCheckpointAPI.js';
+
+export * from './implementation/BucketDefinitionMapping.js';
+export * from './implementation/IncrementalReprocessingCompatibility.js';
+export * from './implementation/IncrementalReprocessingSyncConfigLog.js';
+export * from './implementation/ReplicationStreamStorageIds.js';

package/src/sync/BucketChecksumState.ts

@@ -2,7 +2,7 @@ import {
   BucketParameterQuerier,
   BucketPriority,
   BucketSource,
-  HydratedSyncRules,
+  HydratedSyncConfig,
   mergeBuckets,
   QuerierError,
   RequestedStream,
@@ -28,7 +28,7 @@ import { getIntersection, hasIntersection } from './util.js';
 export interface BucketChecksumStateOptions {
   syncContext: SyncContext;
   bucketStorage: BucketChecksumStateStorage;
-  syncRules: HydratedSyncRules;
+  syncRules: HydratedSyncConfig;
   tokenPayload: JwtPayload;
   syncRequest: util.StreamingSyncRequest;
   logger?: Logger;
@@ -285,7 +285,7 @@ export class BucketChecksumState {
       const streamNameToIndex = new Map<string, number>();
       this.streamNameToIndex = streamNameToIndex;
 
-      for (const source of this.parameterState.syncRules.definition.bucketSources) {
+      for (const source of this.parameterState.syncRules.bucketSourceDefinitions) {
         if (this.parameterState.isSubscribedToStream(source)) {
           streamNameToIndex.set(source.name, subscriptions.length);
 
@@ -416,7 +416,7 @@ export interface CheckpointUpdate {
 export class BucketParameterState {
   private readonly context: SyncContext;
   public readonly bucketStorage: BucketChecksumStateStorage;
-  public readonly syncRules: HydratedSyncRules;
+  public readonly syncRules: HydratedSyncConfig;
   public readonly syncParams: RequestParameters;
   private readonly querier: BucketParameterQuerier;
   /**
@@ -439,7 +439,7 @@ export class BucketParameterState {
   constructor(
     context: SyncContext,
     bucketStorage: BucketChecksumStateStorage,
-    syncRules: HydratedSyncRules,
+    syncRules: HydratedSyncConfig,
     tokenPayload: JwtPayload,
     request: util.StreamingSyncRequest,
     logger: Logger

package/src/sync/sync.ts

@@ -1,5 +1,5 @@
 import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
-import { BucketPriority, HydratedSyncRules, ResolvedBucket, SqliteJsonValue } from '@powersync/service-sync-rules';
+import { BucketPriority, HydratedSyncConfig, ResolvedBucket, SqliteJsonValue } from '@powersync/service-sync-rules';
 
 import { AbortError } from 'ix/aborterror.js';
 
@@ -17,7 +17,7 @@ import { TokenStreamOptions, acquireSemaphoreAbortable, settledPromise, tokenStr
 export interface SyncStreamParameters {
   syncContext: SyncContext;
   bucketStorage: storage.SyncRulesBucketStorage;
-  syncRules: HydratedSyncRules;
+  syncRules: HydratedSyncConfig;
   params: util.StreamingSyncRequest;
   token: auth.JwtPayload;
   logger?: Logger;
@@ -94,7 +94,7 @@ export async function* streamResponse(
 async function* streamResponseInner(
   syncContext: SyncContext,
   bucketStorage: storage.SyncRulesBucketStorage,
-  syncRules: HydratedSyncRules,
+  syncRules: HydratedSyncConfig,
   params: util.StreamingSyncRequest,
   tokenPayload: auth.JwtPayload,
   tracker: RequestTracker,
@@ -367,6 +367,11 @@ async function* bucketDataBatch(request: BucketDataRequest): AsyncGenerator<Buck
         checkpointInvalidated = true;
       }
       if (r.data.length == 0) {
+        // An empty chunk is not sent to the client, but may still report progress:
+        // storage can emit an empty chunk for a bucket that has no operations in the
+        // requested range, and its position must advance so the bucket is not
+        // re-requested indefinitely.
+        checkpointLine.updateBucketPosition({ bucket: r.bucket, nextAfter: BigInt(r.next_after), hasMore: r.has_more });
         continue;
       }
       logger.debug(`Sending data for ${r.bucket}`);

package/src/tracing/PerformanceTracer.ts

@@ -2,19 +2,38 @@ import { traceWriter } from './TraceWriter.js';
 
 export interface Span extends Disposable {
   name: string;
+  /**
+   * Start time in microseconds since an arbitrary epoch.
+   */
   startAt: number;
+  /**
+   * End time in microseconds since an arbitrary epoch.
+   */
   endAt: number;
+  /**
+   * Time spent not in nested spans.
+   */
   selfDuration: number;
+
   nestedSince: number | undefined;
   subtrackFromSelf: number;
+
+  /**
+   * Durations spent in nested spans, in microseconds.
+   */
   nestedDurations: Record<string, number>;
 
+  /**
+   * Total duration of this span in milliseconds, rounded up. Only valid after the span has ended.
+   */
+  durationMillis: number;
+
   /**
    * End the span - same as [Symbol.dispose]().
    *
    * Safe to call multiple times. Any nested spans will automatically end as well.
    *
-   * Returns an aggregate record of category -> "selfDuration".
+   * Returns an aggregate record of category -> "selfDuration", in microseconds.
    */
   end(): Record<string, number>;
 }
@@ -115,6 +134,10 @@ export class PerformanceTracer<K extends string> {
         }
         return this.nestedDurations;
       },
+
+      get durationMillis() {
+        return Math.ceil((this.endAt - this.startAt) / 1000);
+      },
       [Symbol.dispose]() {
         this.end();
       }

package/src/util/checkpointing.ts

@@ -11,7 +11,7 @@ export interface CreateWriteCheckpointOptions {
 export async function createWriteCheckpoint(options: CreateWriteCheckpointOptions) {
   const full_user_id = checkpointUserId(options.userId, options.clientId);
 
-  const syncBucketStorage = await options.storage.getActiveStorage();
+  const syncBucketStorage = (await options.storage.getActiveSyncConfig())?.storage;
   if (!syncBucketStorage) {
     throw new ServiceError(ErrorCode.PSYNC_S2302, `Cannot create Write Checkpoint since no sync config is active.`);
   }

package/src/util/config/types.ts

@@ -55,7 +55,7 @@ export type ResolvedPowerSyncConfig = {
     max_parameter_query_results: number;
   };
 
-  /** Prefix for postgres replication slot names. May eventually be connection-specific. */
+  /** Prefix for postgres replication slot names, as well as replication stream names. */
   slot_name_prefix: string;
 
   healthcheck: {

package/src/util/lsn.ts

@@ -6,3 +6,12 @@ export function maxLsn(a: string | null | undefined, b: string | null | undefine
   if (b == null) return a;
   return a > b ? a : b;
 }
+
+/**
+ * Return the smaller of two LSNs, ignoring nulls.
+ */
+export function minLsn(a: string | null | undefined, b: string | null | undefined): string | null {
+  if (a == null) return b ?? null;
+  if (b == null) return a;
+  return a < b ? a : b;
+}

package/src/util/util-index.ts

@@ -17,6 +17,7 @@ export * from './config/collectors/config-collector.js';
 export * from './config/collectors/impl/base64-config-collector.js';
 export * from './config/collectors/impl/fallback-config-collector.js';
 export * from './config/collectors/impl/filesystem-config-collector.js';
+export * from './config/collectors/impl/yaml-env.js';
 
 export * from './config/sync-rules/impl/base64-sync-rules-collector.js';
 export * from './config/sync-rules/impl/filesystem-sync-rules-collector.js';

package/src/util/utils.ts

@@ -39,6 +39,14 @@ export function escapeIdentifier(identifier: string) {
   return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
 }
 
+/**
+ *  Sanitized name of the entity in the format of "{schema}.{entity name}"
+ *  Suitable for safe use in Postgres queries and in log output.
+ */
+export function qualifiedName(ref: sync_rules.SourceTableRef) {
+  return `${escapeIdentifier(ref.schema)}.${escapeIdentifier(ref.name)}`;
+}
+
 export function hashData(type: string, id: string, data: string): number {
   const hash = crypto.createHash('sha256');
   hash.update(`put.${type}.${id}.${data}`);

package/test/src/auth.test.ts

@@ -484,6 +484,17 @@ describe('JWT Auth', () => {
           }
         })
     ).toThrowError('IPs in this range are not supported');
+
+    // `URL.hostname` exposes IPv6 literals wrapped in brackets; ensure they are
+    // handled like other direct-IP cases.
+    expect(
+      () =>
+        new RemoteJWKSCollector('https://[::1]/.well-known/jwks.json', {
+          lookupOptions: {
+            reject_ip_ranges: ['local']
+          }
+        })
+    ).toThrowError('IPs in this range are not supported');
   });
 
   test('http not blocking local IPs', async () => {

package/test/src/diagnostics.test.ts

@@ -1,6 +1,6 @@
 import { DiagnosticsOptions, getSyncRulesStatus } from '@/api/diagnostics.js';
 import { RouteAPI, SlotWalBudgetInfo } from '@/api/RouteAPI.js';
-import { BucketStorageFactory } from '@/index.js';
+import { ParsedSyncConfigSet, storage } from '@/index.js';
 import { SqlSyncRules } from '@powersync/service-sync-rules';
 import { describe, expect, test } from 'vitest';
 
@@ -13,49 +13,56 @@ bucket_definitions:
       - SELECT id FROM test_table
 `;
 
-function makeSyncRulesContent(overrides?: { slot_name?: string }) {
+function makeSyncRulesContent(overrides?: {
+  slot_name?: string;
+  status?: storage.PersistedSyncConfigStatus;
+}): storage.PersistedSyncConfigContent {
+  // We don't implement the entire interface correctly here - just enough to test the diagnostics logic.
   return {
-    id: 1,
-    slot_name: overrides?.slot_name ?? 'test_slot',
+    replicationStreamId: 1,
+    syncConfigId: null,
+    replicationStreamName: overrides?.slot_name ?? 'test_slot',
     sync_rules_content: MINIMAL_SYNC_RULES,
     compiled_plan: null,
-    active: true,
     storageVersion: 1,
-    last_checkpoint_lsn: 'some_lsn',
-    last_fatal_error: null,
-    last_fatal_error_ts: null,
-    last_keepalive_ts: new Date(),
-    last_checkpoint_ts: new Date(),
     parsed(options?: any) {
       const syncRules = SqlSyncRules.fromYaml(MINIMAL_SYNC_RULES, {
         ...options,
         defaultSchema: 'public'
       });
       return {
-        sync_rules: syncRules
-      };
-    },
-    lock() {
-      throw new Error('Not implemented in mock');
+        syncConfigs: [syncRules]
+      } as ParsedSyncConfigSet;
     },
-    current_lock: undefined
-  } as any;
+    logger: null as any,
+    asUpdateOptions: null as any,
+    getStorageConfig: null as any,
+    async getSyncConfigStatus() {
+      return (
+        overrides?.status ?? {
+          id: '1',
+          replicationStreamId: 1,
+          state: storage.SyncRuleState.ACTIVE,
+          last_checkpoint_lsn: 'some_lsn',
+          last_fatal_error: null,
+          last_fatal_error_ts: null,
+          last_keepalive_ts: new Date(),
+          last_checkpoint_ts: new Date()
+        }
+      );
+    }
+  } as storage.PersistedSyncConfigContent;
 }
 
-function makeBucketStorage() {
+function makeSystemStorage() {
   return {
-    getInstance() {
+    async getStatus() {
       return {
-        async getStatus() {
-          return {
-            snapshot_done: true,
-            checkpoint_lsn: 'some_lsn',
-            active: true
-          };
-        }
+        snapshotDone: true,
+        resumeLsn: 'some_lsn'
       };
     }
-  } as unknown as BucketStorageFactory;
+  } as storage.SyncRulesBucketStorage;
 }
 
 function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
@@ -88,7 +95,8 @@ function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
 const OPTIONS: DiagnosticsOptions = {
   live_status: true,
   check_connection: true,
-  include_content: false
+  include_content: false,
+  active: true
 };
 
 describe('getSyncRulesStatus WAL budget warnings', () => {
@@ -98,7 +106,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: 4 * GB,
       max_slot_wal_keep_size: 10 * GB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(1);
     expect(walWarnings[0].level).toBe('warning');
@@ -111,7 +119,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: 8 * GB,
       max_slot_wal_keep_size: 10 * GB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(0);
   });
@@ -122,7 +130,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
       safe_wal_size: -2.4 * GB,
       max_slot_wal_keep_size: 1 * 1024 * 1024 // 1MB
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
     expect(walWarnings).toHaveLength(1);
     expect(walWarnings[0].message).toContain('0%');
@@ -133,7 +141,7 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
     const api = makeRouteAPI({
       wal_status: 'lost'
     });
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walErrors = result!.errors.filter(
       (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
     );
@@ -142,10 +150,33 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
 
   test('no WAL error when getSlotWalBudget is not defined', async () => {
     const api = makeRouteAPI();
-    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
     const walErrors = result!.errors.filter(
       (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
     );
     expect(walErrors).toHaveLength(0);
   });
+
+  test('uses sync config status for status-derived diagnostics fields', async () => {
+    const configStatus: storage.PersistedSyncConfigStatus = {
+      id: 'config-a',
+      replicationStreamId: 1,
+      state: storage.SyncRuleState.ACTIVE,
+      last_checkpoint_lsn: 'config_lsn',
+      last_fatal_error: 'config failed',
+      last_fatal_error_ts: new Date('2026-01-01T00:00:00.000Z'),
+      last_keepalive_ts: new Date('2026-01-01T00:01:00.000Z'),
+      last_checkpoint_ts: new Date('2026-01-01T00:02:00.000Z')
+    };
+    const result = await getSyncRulesStatus(
+      makeRouteAPI(),
+      makeSyncRulesContent({ status: configStatus }),
+      OPTIONS,
+      makeSystemStorage()
+    );
+
+    expect(result!.connections[0].last_checkpoint_ts).toBe('2026-01-01T00:02:00.000Z');
+    expect(result!.connections[0].last_keepalive_ts).toBe('2026-01-01T00:01:00.000Z');
+    expect(result!.errors.some((error) => error.message == 'config failed')).toBe(true);
+  });
 });

package/test/src/module-loader.test.ts

@@ -1,4 +1,11 @@
-import { AbstractModule, loadModules, ServiceContextContainer, TearDownOptions } from '@/index.js';
+import {
+  AbstractModule,
+  loadModules,
+  ModuleManager,
+  ServiceContextContainer,
+  storage,
+  TearDownOptions
+} from '@/index.js';
 import { describe, expect, it } from 'vitest';
 
 interface MockConfig {
@@ -27,6 +34,19 @@ class MockPostgresStorageModule extends AbstractModule {
   async initialize(context: ServiceContextContainer): Promise<void> {}
   async teardown(options: TearDownOptions): Promise<void> {}
 }
+class RecordingModule extends AbstractModule {
+  teardownOptions: TearDownOptions | undefined;
+
+  constructor(name: string) {
+    super({ name });
+  }
+
+  async initialize(context: ServiceContextContainer): Promise<void> {}
+
+  async teardown(options: TearDownOptions): Promise<void> {
+    this.teardownOptions = options;
+  }
+}
 const mockLoaders = {
   connection: {
     mysql: async () => {
@@ -99,4 +119,16 @@ describe('module loader', () => {
 
     await expect(loadModules(config as any, loaders)).rejects.toThrowError('Failed to load MySQL module');
   });
+
+  it('passes replication streams through teardown options', async () => {
+    const module = new RecordingModule('RecordingModule');
+    const moduleManager = new ModuleManager();
+    const replicationStreams = [{ replicationStreamId: 1 }] as storage.PersistedReplicationStream[];
+
+    moduleManager.register([module]);
+    await moduleManager.tearDown({ replicationStreams, syncRules: replicationStreams });
+
+    expect(module.teardownOptions?.replicationStreams).toBe(replicationStreams);
+    expect(module.teardownOptions?.syncRules).toBe(replicationStreams);
+  });
 });