@powersync/service-core 0.0.0-dev-20260602073133 → 0.0.0-dev-20260909133214

package/src/storage/BucketStorageBatch.ts

@@ -12,6 +12,15 @@ export const DEFAULT_BUCKET_BATCH_COMMIT_OPTIONS: ResolvedBucketBatchCommitOptio
   oldestUncommittedChange: null
 };
 
+/**
+ * Storage writer for a source-specific unit of replication work.
+ *
+ * A batch evaluates source row changes against the hydrated sync config,
+ * persists bucket operations and parameter lookup rows, tracks source table and
+ * snapshot state, records the committed source position for visible
+ * checkpoints, and stores restart cursors for sources with PowerSync-managed
+ * resume state.
+ */
 export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageListener>, AsyncDisposable {
   /**
    * Alias for [Symbol.asyncDispose]
@@ -29,21 +38,28 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
   readonly skipExistingRows: boolean;
 
   /**
-   * Save an op, and potentially flush.
+   * Queue one normalized source row operation and potentially flush.
    *
-   * This can be an insert, update or delete op.
+   * When flushed, the operation is evaluated against data and parameter
+   * queries. That may produce bucket operations, parameter lookup rows, and
+   * current-data updates. `save()` may trigger that flush automatically when
+   * the batch reaches its size limits, but a flush does not create a checkpoint
+   * by itself.
    */
   save(record: SaveOptions): Promise<FlushedResult | null>;
 
   /**
-   * Replicate a truncate op - deletes all data in the specified tables.
+   * Replicate a truncate operation by removing all currently replicated rows
+   * for the specified source tables.
    */
   truncate(sourceTables: SourceTable[]): Promise<FlushedResult | null>;
 
   /**
-   * Drop one or more tables.
+   * Drop one or more source table mappings.
    *
-   * This is the same as truncate, but additionally removes the SourceTable record.
+   * This performs the same logical row removal as `truncate()`, then removes
+   * the stored `SourceTable` record. It is used for table drops, renames,
+   * replica identity changes, and superseded mappings.
    */
   drop(sourceTables: SourceTable[]): Promise<FlushedResult | null>;
 
@@ -58,21 +74,26 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
   flush(options?: BatchBucketFlushOptions): Promise<FlushedResult | null>;
 
   /**
-   * Flush and commit any saved ops. This creates a new checkpoint by default.
+   * Flush saved ops and advance the committed source checkpoint position.
    *
-   * Only call this after a transaction.
+   * Only call this at a source transaction, page, snapshot, or other boundary
+   * where it is valid for clients to observe all flushed changes together. A
+   * single commit may include multiple complete source transactions, but must
+   * not split one source transaction across checkpoint boundaries.
    */
   commit(lsn: string, options?: BucketBatchCommitOptions): Promise<CheckpointResult>;
 
   /**
-   * Advance the checkpoint LSN position, without any associated op.
+   * Advance the committed source checkpoint position without associated row
+   * operations.
    *
-   * This must only be called when not inside a transaction.
+   * Use this for source heartbeats, marker-only events, and idle-source write
+   * checkpoint progress. This must only be called outside a source transaction.
    */
   keepalive(lsn: string): Promise<CheckpointResult>;
 
   /**
-   * Set the LSN that replication should resume from.
+   * Set the source position that replication should resume from after restart.
    *
    * This can be used for:
    * 1. Setting the LSN for a snapshot, before starting replication.
@@ -80,14 +101,13 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    *
    * Not required if the source database keeps track of this, for example with
    * PostgreSQL logical replication slots.
+   *
+   * This is for restart safety only. If the same source position should become
+   * visible to clients, also call `commit()` or `keepalive()` at a valid source
+   * boundary.
    */
   setResumeLsn(lsn: string): Promise<void>;
 
-  /**
-   * Get the last checkpoint LSN, from either commit or keepalive.
-   */
-  lastCheckpointLsn: string | null;
-
   /**
    * LSN to resume from.
    *
@@ -95,7 +115,21 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    */
   resumeFromLsn: string | null;
 
+  /**
+   * Mark table snapshots complete and record the source position that
+   * checkpoints must not precede for those tables.
+   */
   markTableSnapshotDone(tables: SourceTable[], no_checkpoint_before_lsn?: string): Promise<SourceTable[]>;
+
+  /**
+   * Mark a source table as requiring snapshot work again.
+   *
+   * Use this when a table that was previously considered snapshot-complete
+   * must be copied again before it can safely contribute to checkpoints. Common
+   * cases include detected schema or replica identity changes, interrupted
+   * re-snapshot work, or other source metadata changes that make the existing
+   * replicated rows no longer trustworthy.
+   */
   markTableSnapshotRequired(table: SourceTable): Promise<void>;
 
   /**
@@ -118,6 +152,10 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    */
   markSnapshotDone(no_checkpoint_before_lsn: string, options?: { throwOnConflict?: boolean }): Promise<void>;
 
+  /**
+   * Persist resumable table snapshot progress such as row counts or source
+   * cursors.
+   */
   updateTableProgress(table: SourceTable, progress: Partial<TableSnapshotStatus>): Promise<SourceTable>;
 
   /**
@@ -125,10 +163,21 @@ export interface BucketStorageBatch extends ObserverClient<BucketBatchStorageLis
    */
   getSourceTableStatus(table: SourceTable): Promise<SourceTable | null>;
 
+  /**
+   * Resolve discovered source metadata against the active sync config and
+   * persisted source table state.
+   *
+   * @returns Current mappings that should receive replicated rows, plus
+   *          outdated mappings that the source connector should drop.
+   */
   resolveTables(options: ResolveTablesOptions): Promise<ResolveTablesResult>;
 
   /**
-   * Queues the creation of a custom Write Checkpoint. This will be persisted after operations are flushed.
+   * Queue a custom checkpoint request to be persisted after operations are
+   * flushed. Set `checkpoint_requested_at` when the custom checkpoint came from
+   * a client checkpoint request and should be cleaned up by request-retention
+   * compaction; omit it for persistent source-owned checkpoints. Incremental
+   * event handlers should copy `event_id` from their {@link ReplicationEventPayload}.
    */
   addCustomWriteCheckpoint(checkpoint: BatchedCustomWriteCheckpointOptions): void;
 }
@@ -216,8 +265,6 @@ export interface CheckpointResult {
   /**
    * True if a checkpoint was actually created by this operation. This can be false even if checkpointBlocked is false,
    * if the checkpoint was empty.
-   *
-   * This is primarily used for testing.
    */
   checkpointCreated: boolean;
 }

package/src/storage/BucketStorageFactory.ts

@@ -1,6 +1,7 @@
 import { BaseObserver, logger } from '@powersync/lib-services-framework';
 import {
   PrecompiledSyncConfig,
+  SerializedSyncPlan as RawSerializedSyncPlan,
   SerializedCompatibilityContext,
   serializeSyncPlan,
   SqlSyncRules,
@@ -8,7 +9,8 @@ import {
 } from '@powersync/service-sync-rules';
 import { ReplicationError } from '@powersync/service-types';
 import { syncConfigYamlErrorToReplicationError } from '../util/errors.js';
-import { ParseSyncRulesOptions, PersistedSyncRules, PersistedSyncRulesContent } from './PersistedSyncRulesContent.js';
+import { PersistedReplicationStream } from './PersistedReplicationStream.js';
+import { PersistedSyncConfigContent } from './PersistedSyncConfigContent.js';
 import { ReplicationEventPayload } from './ReplicationEventPayload.js';
 import { ReplicationLock } from './ReplicationLock.js';
 import { ReportStorage } from './ReportStorage.js';
@@ -31,14 +33,21 @@ export abstract class BucketStorageFactory
    */
   async configureSyncRules(
     options: UpdateSyncRulesOptions
-  ): Promise<{ updated: boolean; persisted_sync_rules?: PersistedSyncRulesContent; lock?: ReplicationLock }> {
-    const next = await this.getNextSyncRulesContent();
-    const active = await this.getActiveSyncRulesContent();
-
-    if (next?.sync_rules_content == options.config.yaml) {
+  ): Promise<{ updated: boolean; persisted_sync_rules?: PersistedReplicationStream; lock?: ReplicationLock }> {
+    const deploying = await this.getDeployingSyncConfig();
+    const active = await this.getActiveSyncConfig();
+
+    if (
+      deploying?.content.sync_rules_content == options.config.yaml &&
+      deploying.content.version_label == options.version_label
+    ) {
       logger.info('Sync config unchanged');
       return { updated: false };
-    } else if (next == null && active?.sync_rules_content == options.config.yaml) {
+    } else if (
+      deploying == null &&
+      active?.content.sync_rules_content == options.config.yaml &&
+      active.content.version_label == options.version_label
+    ) {
       logger.info('Sync config unchanged');
       return { updated: false };
     } else {
@@ -51,12 +60,15 @@ export abstract class BucketStorageFactory
   /**
    * Get a storage instance to query sync data for specific sync config.
    */
-  abstract getInstance(syncRules: PersistedSyncRulesContent, options?: GetIntanceOptions): SyncRulesBucketStorage;
+  abstract getInstance(
+    replicationStream: PersistedReplicationStream,
+    options?: GetIntanceOptions
+  ): SyncRulesBucketStorage;
 
   /**
    * Deploy new sync config.
    */
-  abstract updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedSyncRulesContent>;
+  abstract updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedReplicationStream>;
 
   /**
    * Indicate that a slot was removed, and we should re-sync by creating
@@ -68,48 +80,27 @@ export abstract class BucketStorageFactory
    *
    * Replication should be restarted after this.
    */
-  abstract restartReplication(sync_rules_group_id: number): Promise<void>;
+  abstract restartReplication(replicationStreamId: number): Promise<void>;
 
   /**
-   * Get the sync config used for querying.
+   * Get the sync config and storage used for querying.
    */
-  async getActiveSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
-    const content = await this.getActiveSyncRulesContent();
-    return content?.parsed(options) ?? null;
-  }
+  abstract getActiveSyncConfig(): Promise<ResolvedSyncConfig | null>;
 
   /**
-   * Get the sync config used for querying.
+   * Get the sync config and storage that is still deploying.
    */
-  abstract getActiveSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
+  abstract getDeployingSyncConfig(): Promise<ResolvedSyncConfig | null>;
 
   /**
-   * Get the sync config that will be active next once done with initial replicatino.
+   * Get all replication streams currently replicating.
    */
-  async getNextSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
-    const content = await this.getNextSyncRulesContent();
-    return content?.parsed(options) ?? null;
-  }
+  abstract getReplicatingReplicationStreams(): Promise<PersistedReplicationStream[]>;
 
   /**
-   * Get the sync config that will be active next once done with initial replicatino.
+   * Get all replication streams stopped but not terminated yet.
    */
-  abstract getNextSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
-
-  /**
-   * Get all sync config currently replicating. Typically this is the "active" and "next" sync config.
-   */
-  abstract getReplicatingSyncRules(): Promise<PersistedSyncRulesContent[]>;
-
-  /**
-   * Get all sync config stopped but not terminated yet.
-   */
-  abstract getStoppedSyncRules(): Promise<PersistedSyncRulesContent[]>;
-
-  /**
-   * Get the active storage instance.
-   */
-  abstract getActiveStorage(): Promise<SyncRulesBucketStorage | null>;
+  abstract getStoppedReplicationStreams(): Promise<PersistedReplicationStream[]>;
 
   /**
    * Get storage size of active replication stream.
@@ -134,6 +125,12 @@ export interface BucketStorageFactoryListener {
   replicationEvent: (event: ReplicationEventPayload) => void;
 }
 
+export interface ResolvedSyncConfig {
+  content: PersistedSyncConfigContent;
+  replicationStream: PersistedReplicationStream;
+  storage: SyncRulesBucketStorage;
+}
+
 export interface StorageMetrics {
   /**
    * Size of operations (bucket_data)
@@ -151,9 +148,32 @@ export interface StorageMetrics {
    * Size of current_data.
    */
   replication_size_bytes: number;
+
+  /**
+   * Size of active object-storage references, such as S3 bucket-data objects.
+   */
+  object_storage_size_bytes?: number;
+
+  /**
+   * Per-sync-config storage sizes, when the storage backend can provide them.
+   */
+  sync_config_metrics?: StorageSyncConfigMetrics[];
+}
+
+export interface StorageSyncConfigMetrics {
+  sync_config_id: string;
+  sync_config_state: string;
+  /** Optional operator-supplied label identifying this sync config version. */
+  version_label?: string;
+  attributed_bucket_data_bytes: number;
+  attributed_parameter_indexes_bytes: number;
+  attributed_source_records_bytes: number;
+  attributed_object_storage_bytes: number;
 }
 
 export interface UpdateSyncRulesOptions {
+  /** Optional operator-supplied label identifying this deployed sync config version. */
+  version_label?: string;
   config: {
     yaml: string;
     /**
@@ -171,6 +191,12 @@ export interface UpdateSyncRulesOptions {
   lock?: boolean;
   storageVersion?: number;
 
+  /**
+   * Start a replacement replication stream instead of incrementally reprocessing a
+   * compatible active stream. Used when the current stream needs a full reprocess.
+   */
+  forceNewReplicationStream?: boolean;
+
   /**
    * Only relevant if the result is used. This does not affect the persisted config.
    */
@@ -181,14 +207,13 @@ export interface SerializedSyncPlan {
   /**
    * The serialized plan, from {@link serializeSyncPlan}.
    */
-  plan: unknown;
+  plan: RawSerializedSyncPlan;
   compatibility: SerializedCompatibilityContext;
   /**
-   * Event descriptors are not currently represented in the sync plan because they don't use the sync streams compiler
-   * yet.
+   * Raw event SQL persisted as a compatibility mirror for compiled {@link plan} events.
    *
-   * We might revisit that in the future, but for now we store SQL text of their definitions here to be able to restore
-   * them.
+   * Compiled events are an additive plan field. Older services ignore that field and restore these descriptors through
+   * the legacy evaluator. Keep dual-writing this field until a future plan version explicitly removes that support.
    */
   eventDescriptors: Record<string, string[]>;
   errors?: ReplicationError[];
@@ -216,13 +241,14 @@ export function updateSyncRulesFromConfig(
   const { config, errors } = parsed;
   if (config instanceof PrecompiledSyncConfig) {
     const eventDescriptors: Record<string, string[]> = {};
-    for (const event of config.eventDescriptors) {
-      eventDescriptors[event.name] = event.sourceQueries.map((q) => q.sql);
+    for (const event of config.plan.events) {
+      eventDescriptors[event.name] = event.sourceQueries.map((query) => query.sql);
     }
 
     plan = {
       compatibility: config.compatibility.serialize(),
       plan: serializeSyncPlan(config.plan),
+      // Dual-write raw SQL so older services can ignore additive compiled plan events without losing event behavior.
       eventDescriptors,
       errors: errors.map((e) => syncConfigYamlErrorToReplicationError(e))
     };
@@ -278,4 +304,5 @@ export interface TestStorageConfig {
   factory: TestStorageFactory;
   tableIdStrings: boolean;
   storageVersion?: number;
+  compressedBucketStorage?: boolean;
 }

package/src/storage/CheckpointChecksumInvalidatedError.ts

@@ -0,0 +1,17 @@
+import { InternalOpId } from '../util/util-index.js';
+
+/**
+ * A checkpoint cannot be served because compaction rewrote a bucket-data
+ * document across its end boundary.
+ *
+ * The sync loop must skip this checkpoint before it sends its checkpoint line.
+ */
+export class CheckpointChecksumInvalidatedError extends Error {
+  constructor(
+    public readonly checkpoint: InternalOpId,
+    public readonly bucket: string
+  ) {
+    super(`Checkpoint ${checkpoint} was invalidated by compaction in bucket ${bucket}`);
+    this.name = 'CheckpointChecksumInvalidatedError';
+  }
+}

package/src/storage/ChecksumCache.ts

@@ -5,7 +5,7 @@ import { BucketChecksum } from '../util/protocol-types.js';
 import { addBucketChecksums, ChecksumMap, InternalOpId, PartialChecksum } from '../util/utils.js';
 import { BucketChecksumRequest } from './SyncRulesBucketStorage.js';
 
-interface ChecksumFetchContext {
+interface ChecksumFetchContext<TContext> {
   fetch(bucket: string): Promise<BucketChecksum>;
   checkpoint: InternalOpId;
 }
@@ -20,26 +20,35 @@ export interface FetchPartialBucketChecksum {
 export type PartialOrFullChecksum = PartialChecksum | BucketChecksum;
 export type PartialChecksumMap = Map<string, PartialOrFullChecksum>;
 
-export type FetchChecksums = (batch: FetchPartialBucketChecksum[]) => Promise<PartialChecksumMap>;
+export type FetchChecksums<TContext = undefined> = (
+  batch: FetchPartialBucketChecksum[],
+  context: TContext
+) => Promise<PartialChecksumMap>;
 
-export interface ChecksumCacheOptions {
+export interface ChecksumCacheOptions<TContext = undefined> {
   /**
    * Upstream checksum implementation.
    *
    * This fetches a batch of either entire bucket checksums, or a partial range.
    */
-  fetchChecksums: FetchChecksums;
+  fetchChecksums: FetchChecksums<TContext>;
 
   /**
    * Maximum number of cached checksums.
    */
   maxSize?: number;
+
+  /**
+   * How long to keep cached checksums before refreshing them.
+   */
+  ttlMs?: number;
 }
 
 // Approximately 5MB of memory, if we assume 50 bytes per entry
 const DEFAULT_MAX_SIZE = 100_000;
 
-const TTL_MS = 3_600_000;
+// Default to 1h
+export const DEFAULT_CHECKSUM_CACHE_TTL_MS = 1 * 3_600_000;
 
 /**
  * Implement a LRU cache for checksum requests. Each (bucket, checkpoint) request is cached separately,
@@ -50,22 +59,22 @@ const TTL_MS = 3_600_000;
  *
  * We use the LRUCache fetchMethod to deduplicate in-progress requests.
  */
-export class ChecksumCache {
+export class ChecksumCache<TContext = undefined> {
   /**
    * The primary checksum cache, with key of `${checkpoint}/${bucket}`.
    */
-  private cache: LRUCache<string, BucketChecksum, ChecksumFetchContext>;
+  private cache: LRUCache<string, BucketChecksum, ChecksumFetchContext<TContext>>;
   /**
    * For each bucket, an ordered set of cached checkpoints.
    */
   private bucketCheckpoints = new Map<string, OrderedSet<bigint>>();
 
-  private fetchChecksums: FetchChecksums;
+  private fetchChecksums: FetchChecksums<TContext>;
 
-  constructor(options: ChecksumCacheOptions) {
+  constructor(options: ChecksumCacheOptions<TContext>) {
     this.fetchChecksums = options.fetchChecksums;
 
-    this.cache = new LRUCache<string, BucketChecksum, ChecksumFetchContext>({
+    this.cache = new LRUCache<string, BucketChecksum, ChecksumFetchContext<TContext>>({
       max: options.maxSize ?? DEFAULT_MAX_SIZE,
       fetchMethod: async (cacheKey, _staleValue, options) => {
         // Called when this checksum hasn't been cached yet.
@@ -105,7 +114,7 @@ export class ChecksumCache {
       // We use a TTL so that counts can eventually be refreshed
       // after a compact. This only has effect if the bucket has
       // not been checked in the meantime.
-      ttl: TTL_MS,
+      ttl: options.ttlMs ?? DEFAULT_CHECKSUM_CACHE_TTL_MS,
       ttlResolution: 1_000,
       allowStale: false
     });
@@ -129,7 +138,11 @@ export class ChecksumCache {
    *
    * @returns a Map with exactly one entry for each bucket requested
    */
-  async getChecksumMap(checkpoint: InternalOpId, buckets: BucketChecksumRequest[]): Promise<ChecksumMap> {
+  async getChecksumMap(
+    checkpoint: InternalOpId,
+    buckets: BucketChecksumRequest[],
+    fetchContext?: TContext
+  ): Promise<ChecksumMap> {
     // Buckets that don't have a cached checksum for this checkpoint yet
     let toFetch = new Set<string>();
 
@@ -147,7 +160,7 @@ export class ChecksumCache {
     // Accumulated results - both from cached checksums, and fetched checksums
     let finalResults = new Map<string, BucketChecksum>();
 
-    const context: ChecksumFetchContext = {
+    const context: ChecksumFetchContext<TContext> = {
       async fetch(bucket) {
         await fetchPromise;
         if (!toFetch.has(bucket)) {
@@ -260,7 +273,7 @@ export class ChecksumCache {
         }
 
         // Fetch partial checksums from upstream
-        const results = await this.fetchChecksums(bucketRequests);
+        const results = await this.fetchChecksums(bucketRequests, fetchContext as TContext);
 
         for (let bucket of toFetch) {
           const result = results.get(bucket);

package/src/storage/ParsedSyncConfigSet.ts

@@ -0,0 +1,25 @@
+import { HydratedSyncConfig, HydrationState, SyncConfigWithErrors } from '@powersync/service-sync-rules';
+
+/**
+ * A parsed sync config set is the identity boundary for parsed sync config state.
+ *
+ * All values on a single instance - the parsed configs, hydration state and hydrated
+ * sync config - are derived from the same parse, and may be associated with each other
+ * by object identity. Values from two different instances must never be mixed, even if
+ * they were parsed from the same persisted content.
+ */
+export interface ParsedSyncConfigSet {
+  readonly replicationStreamId: number;
+  readonly replicationStreamName: string;
+  readonly syncConfigs: SyncConfigWithErrors[];
+  /**
+   * For testing only.
+   */
+  readonly hydrationState: HydrationState;
+
+  /**
+   * The hydrated sync config for this parse. This is a stable property: repeated reads
+   * return the same instance.
+   */
+  readonly hydratedSyncConfig: HydratedSyncConfig;
+}

package/src/storage/PersistedReplicationStream.ts

@@ -0,0 +1,55 @@
+import { logger as defaultLogger, ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { Logger } from 'winston';
+import { SyncRuleState } from './BucketStorage.js';
+import type { ParsedSyncConfigSet } from './ParsedSyncConfigSet.js';
+import type { ParseSyncConfigOptions, PersistedSyncConfigContent } from './PersistedSyncConfigContent.js';
+import { ReplicationLock } from './ReplicationLock.js';
+import { STORAGE_VERSION_CONFIG, StorageVersionConfig } from './StorageVersionConfig.js';
+
+export abstract class PersistedReplicationStream implements PersistedReplicationStreamData {
+  readonly replicationStreamId: number;
+  readonly replicationJobId: string;
+  readonly replicationStreamName: string;
+  readonly state: SyncRuleState;
+  readonly storageVersion: number;
+  readonly logger: Logger;
+
+  abstract readonly syncConfigContent: readonly PersistedSyncConfigContent[];
+  abstract readonly current_lock: ReplicationLock | null;
+
+  constructor(data: PersistedReplicationStreamData) {
+    this.replicationStreamId = data.replicationStreamId;
+    this.replicationJobId = data.replicationJobId ?? String(data.replicationStreamId);
+    this.replicationStreamName = data.replicationStreamName;
+    this.state = data.state;
+    this.storageVersion = data.storageVersion;
+    this.logger = defaultLogger.child({ prefix: `[${this.replicationStreamName}] ` });
+  }
+
+  getStorageConfig(): StorageVersionConfig {
+    const storageConfig = STORAGE_VERSION_CONFIG[this.storageVersion];
+    if (storageConfig == null) {
+      throw new ServiceError(
+        ErrorCode.PSYNC_S1005,
+        `Unsupported storage version ${this.storageVersion} for replication stream ${this.replicationStreamId}`
+      );
+    }
+    return storageConfig;
+  }
+
+  abstract lock(): Promise<ReplicationLock>;
+
+  abstract parsed(options: ParseSyncConfigOptions): ParsedSyncConfigSet;
+}
+export interface PersistedReplicationStreamData {
+  readonly replicationStreamId: number;
+  readonly replicationStreamName: string;
+  readonly state: SyncRuleState;
+  readonly storageVersion: number;
+  /**
+   * Uniquely identifies a job, as a combination of replication stream and processing sync configs.
+   *
+   * Used in-memory only.
+   */
+  readonly replicationJobId?: string;
+}