@tanstack/db 0.5.11 → 0.5.12

package/src/query/predicate-utils.ts

@@ -1,6 +1,6 @@
-import { Func, Value } from "./ir.js"
-import type { BasicExpression, OrderBy, PropRef } from "./ir.js"
-import type { LoadSubsetOptions } from "../types.js"
+import { Func, Value } from './ir.js'
+import type { BasicExpression, OrderBy, PropRef } from './ir.js'
+import type { LoadSubsetOptions } from '../types.js'
 
 /**
  * Check if one where clause is a logical subset of another.
@@ -20,7 +20,7 @@ import type { LoadSubsetOptions } from "../types.js"
  */
 export function isWhereSubset(
   subset: BasicExpression<boolean> | undefined,
-  superset: BasicExpression<boolean> | undefined
+  superset: BasicExpression<boolean> | undefined,
 ): boolean {
   // undefined/missing where clause means "no filter" (all data)
   // Both undefined means subset relationship holds (all data ⊆ all data)
@@ -44,7 +44,7 @@ export function isWhereSubset(
 }
 
 function makeDisjunction(
-  preds: Array<BasicExpression<boolean>>
+  preds: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> {
   if (preds.length === 0) {
     return new Value(false)
@@ -57,14 +57,14 @@ function makeDisjunction(
 
 function convertInToOr(inField: InField) {
   const equalities = inField.values.map(
-    (value) => new Func(`eq`, [inField.ref, new Value(value)])
+    (value) => new Func(`eq`, [inField.ref, new Value(value)]),
   )
   return makeDisjunction(equalities)
 }
 
 function isWhereSubsetInternal(
   subset: BasicExpression<boolean>,
-  superset: BasicExpression<boolean>
+  superset: BasicExpression<boolean>,
 ): boolean {
   // If subset is false it is requesting no data,
   // thus the result set is empty
@@ -83,7 +83,7 @@ function isWhereSubsetInternal(
   // Example: (age > 20) ⊆ (age > 10 AND status = 'active') is false (doesn't imply status condition)
   if (superset.type === `func` && superset.name === `and`) {
     return superset.args.every((arg) =>
-      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>)
+      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>),
     )
   }
 
@@ -91,7 +91,7 @@ function isWhereSubsetInternal(
   if (subset.type === `func` && subset.name === `and`) {
     // For (A AND B) ⊆ C, since (A AND B) implies A, we check if any conjunct implies C
     return subset.args.some((arg) =>
-      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset)
+      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset),
     )
   }
 
@@ -114,7 +114,7 @@ function isWhereSubsetInternal(
   // Handle OR in subset: (A OR B) is subset of C only if both A and B are subsets of C
   if (subset.type === `func` && subset.name === `or`) {
     return subset.args.every((arg) =>
-      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset)
+      isWhereSubsetInternal(arg as BasicExpression<boolean>, superset),
     )
   }
 
@@ -123,7 +123,7 @@ function isWhereSubsetInternal(
   // If subset is contained in any disjunct, it's contained in the union
   if (superset.type === `func` && superset.name === `or`) {
     return superset.args.some((arg) =>
-      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>)
+      isWhereSubsetInternal(subset, arg as BasicExpression<boolean>),
     )
   }
 
@@ -145,7 +145,7 @@ function isWhereSubsetInternal(
         subsetFunc,
         subsetField.value,
         supersetFunc,
-        supersetField.value
+        supersetField.value,
       )
     }
 
@@ -205,8 +205,8 @@ function combineWherePredicates(
   predicates: Array<BasicExpression<boolean>>,
   operation: `and` | `or`,
   simplifyFn: (
-    preds: Array<BasicExpression<boolean>>
-  ) => BasicExpression<boolean> | null
+    preds: Array<BasicExpression<boolean>>,
+  ) => BasicExpression<boolean> | null,
 ): BasicExpression<boolean> {
   const emptyValue = operation === `and` ? true : false
   const identityValue = operation === `and` ? true : false
@@ -293,7 +293,7 @@ function combineWherePredicates(
  * @returns Combined predicate representing the union
  */
 export function unionWherePredicates(
-  predicates: Array<BasicExpression<boolean>>
+  predicates: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> {
   return combineWherePredicates(predicates, `or`, unionSameFieldPredicates)
 }
@@ -337,7 +337,7 @@ export function unionWherePredicates(
  */
 export function minusWherePredicates(
   fromPredicate: BasicExpression<boolean> | undefined,
-  subtractPredicate: BasicExpression<boolean> | undefined
+  subtractPredicate: BasicExpression<boolean> | undefined,
 ): BasicExpression<boolean> | null {
   // If nothing to subtract, return the original
   if (subtractPredicate === undefined) {
@@ -367,20 +367,20 @@ export function minusWherePredicates(
   // Try to detect and handle common conditions
   const commonConditions = findCommonConditions(
     fromPredicate,
-    subtractPredicate
+    subtractPredicate,
   )
   if (commonConditions.length > 0) {
     // Extract predicates without common conditions
     const fromWithoutCommon = removeConditions(fromPredicate, commonConditions)
     const subtractWithoutCommon = removeConditions(
       subtractPredicate,
-      commonConditions
+      commonConditions,
     )
 
     // Recursively compute difference on simplified predicates
     const simplifiedDifference = minusWherePredicates(
       fromWithoutCommon,
-      subtractWithoutCommon
+      subtractWithoutCommon,
     )
 
     if (simplifiedDifference !== null) {
@@ -406,7 +406,7 @@ export function minusWherePredicates(
  */
 function minusSameFieldPredicates(
   fromPred: Func,
-  subtractPred: Func
+  subtractPred: Func,
 ): BasicExpression<boolean> | null {
   // Extract field information
   const fromField =
@@ -439,8 +439,8 @@ function minusSameFieldPredicates(
           subtractInField.values,
           v,
           subtractInField.primitiveSet ?? null,
-          subtractInField.areAllPrimitives
-        )
+          subtractInField.areAllPrimitives,
+        ),
     )
 
     if (remainingValues.length === 0) {
@@ -468,7 +468,7 @@ function minusSameFieldPredicates(
     const subtractValue = (subtractField as { ref: PropRef; value: any }).value
 
     const remainingValues = fromInField.values.filter(
-      (v) => !areValuesEqual(v, subtractValue)
+      (v) => !areValuesEqual(v, subtractValue),
     )
 
     if (remainingValues.length === 0) {
@@ -517,7 +517,7 @@ function minusSameFieldPredicates(
       fromPred,
       fromComp.value,
       subtractPred,
-      subtractComp.value
+      subtractComp.value,
     )
     return result
   }
@@ -533,7 +533,7 @@ function minusRangePredicates(
   fromFunc: Func,
   fromValue: any,
   subtractFunc: Func,
-  subtractValue: any
+  subtractValue: any,
 ): BasicExpression<boolean> | null {
   const fromOp = fromFunc.name as `gt` | `gte` | `lt` | `lte` | `eq`
   const subtractOp = subtractFunc.name as `gt` | `gte` | `lt` | `lte` | `eq`
@@ -712,7 +712,7 @@ function minusRangePredicates(
  */
 export function isOrderBySubset(
   subset: OrderBy | undefined,
-  superset: OrderBy | undefined
+  superset: OrderBy | undefined,
 ): boolean {
   // No ordering requirement is always satisfied
   if (!subset || subset.length === 0) {
@@ -742,7 +742,7 @@ export function isOrderBySubset(
     if (
       !areCompareOptionsEqual(
         subClause.compareOptions,
-        superClause.compareOptions
+        superClause.compareOptions,
       )
     ) {
       return false
@@ -756,6 +756,9 @@ export function isOrderBySubset(
  * Check if one limit is a subset of another.
  * Returns true if the subset limit requirements are satisfied by the superset limit.
  *
+ * Note: This function does NOT consider offset. For offset-aware subset checking,
+ * use `isOffsetLimitSubset` instead.
+ *
  * @example
  * isLimitSubset(10, 20) // true (requesting 10 items when 20 are available)
  * isLimitSubset(20, 10) // false (requesting 20 items when only 10 are available)
@@ -767,7 +770,7 @@ export function isOrderBySubset(
  */
 export function isLimitSubset(
   subset: number | undefined,
-  superset: number | undefined
+  superset: number | undefined,
 ): boolean {
   // Unlimited superset satisfies any limit requirement
   if (superset === undefined) {
@@ -785,7 +788,57 @@ export function isLimitSubset(
 }
 
 /**
- * Check if one predicate (where + orderBy + limit) is a subset of another.
+ * Check if one offset+limit range is a subset of another.
+ * Returns true if the subset range is fully contained within the superset range.
+ *
+ * A query with `{limit: 10, offset: 0}` loads rows [0, 10).
+ * A query with `{limit: 10, offset: 20}` loads rows [20, 30).
+ *
+ * For subset to be satisfied by superset:
+ * - Superset must start at or before subset (superset.offset <= subset.offset)
+ * - Superset must end at or after subset (superset.offset + superset.limit >= subset.offset + subset.limit)
+ *
+ * @example
+ * isOffsetLimitSubset({ offset: 0, limit: 5 }, { offset: 0, limit: 10 }) // true
+ * isOffsetLimitSubset({ offset: 5, limit: 5 }, { offset: 0, limit: 10 }) // true (rows 5-9 within 0-9)
+ * isOffsetLimitSubset({ offset: 5, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 5-14 exceed 0-9)
+ * isOffsetLimitSubset({ offset: 20, limit: 10 }, { offset: 0, limit: 10 }) // false (rows 20-29 outside 0-9)
+ *
+ * @param subset - The offset+limit requirements to check
+ * @param superset - The offset+limit that might satisfy the requirements
+ * @returns true if subset range is fully contained within superset range
+ */
+export function isOffsetLimitSubset(
+  subset: { offset?: number; limit?: number },
+  superset: { offset?: number; limit?: number },
+): boolean {
+  const subsetOffset = subset.offset ?? 0
+  const supersetOffset = superset.offset ?? 0
+
+  // Superset must start at or before subset
+  if (supersetOffset > subsetOffset) {
+    return false
+  }
+
+  // If superset is unlimited, it covers everything from its offset onwards
+  if (superset.limit === undefined) {
+    return true
+  }
+
+  // If subset is unlimited but superset has a limit, subset can't be satisfied
+  if (subset.limit === undefined) {
+    return false
+  }
+
+  // Both have limits - check if subset range is within superset range
+  const subsetEnd = subsetOffset + subset.limit
+  const supersetEnd = supersetOffset + superset.limit
+
+  return subsetEnd <= supersetEnd
+}
+
+/**
+ * Check if one predicate (where + orderBy + limit + offset) is a subset of another.
  * Returns true if all aspects of the subset predicate are satisfied by the superset.
  *
  * @example
@@ -800,7 +853,7 @@ export function isLimitSubset(
  */
 export function isPredicateSubset(
   subset: LoadSubsetOptions,
-  superset: LoadSubsetOptions
+  superset: LoadSubsetOptions,
 ): boolean {
   // When the superset has a limit, we can only determine subset relationship
   // if the where clauses are equal (not just subset relationship).
@@ -813,9 +866,9 @@ export function isPredicateSubset(
   // The top 10 items matching 'search%' might include items outside the overall top 10.
   //
   // However, if the where clauses are equal, then the subset relationship can
-  // be determined by orderBy and limit alone:
-  // Example: superset = {where: status='active', limit: 10, orderBy: desc}
-  //          subset = {where: status='active', limit: 5, orderBy: desc}
+  // be determined by orderBy, limit, and offset:
+  // Example: superset = {where: status='active', limit: 10, offset: 0, orderBy: desc}
+  //          subset = {where: status='active', limit: 5, offset: 0, orderBy: desc}
   // The top 5 active items ARE contained in the top 10 active items.
   if (superset.limit !== undefined) {
     // For limited supersets, where clauses must be equal
@@ -824,15 +877,17 @@ export function isPredicateSubset(
     }
     return (
       isOrderBySubset(subset.orderBy, superset.orderBy) &&
-      isLimitSubset(subset.limit, superset.limit)
+      isOffsetLimitSubset(subset, superset)
     )
   }
 
   // For unlimited supersets, use the normal subset logic
+  // Still need to consider offset - an unlimited query with offset only covers
+  // rows from that offset onwards
   return (
     isWhereSubset(subset.where, superset.where) &&
     isOrderBySubset(subset.orderBy, superset.orderBy) &&
-    isLimitSubset(subset.limit, superset.limit)
+    isOffsetLimitSubset(subset, superset)
   )
 }
 
@@ -842,7 +897,7 @@ export function isPredicateSubset(
  */
 function areWhereClausesEqual(
   a: BasicExpression<boolean> | undefined,
-  b: BasicExpression<boolean> | undefined
+  b: BasicExpression<boolean> | undefined,
 ): boolean {
   if (a === undefined && b === undefined) {
     return true
@@ -863,7 +918,7 @@ function areWhereClausesEqual(
  */
 function findCommonConditions(
   predicate1: BasicExpression<boolean>,
-  predicate2: BasicExpression<boolean>
+  predicate2: BasicExpression<boolean>,
 ): Array<BasicExpression<boolean>> {
   const conditions1 = extractAllConditions(predicate1)
   const conditions2 = extractAllConditions(predicate2)
@@ -889,7 +944,7 @@ function findCommonConditions(
  * Extract all individual conditions from a predicate, flattening AND operations.
  */
 function extractAllConditions(
-  predicate: BasicExpression<boolean>
+  predicate: BasicExpression<boolean>,
 ): Array<BasicExpression<boolean>> {
   if (predicate.type === `func` && predicate.name === `and`) {
     const conditions: Array<BasicExpression<boolean>> = []
@@ -908,14 +963,14 @@ function extractAllConditions(
  */
 function removeConditions(
   predicate: BasicExpression<boolean>,
-  conditionsToRemove: Array<BasicExpression<boolean>>
+  conditionsToRemove: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> | undefined {
   if (predicate.type === `func` && predicate.name === `and`) {
     const remainingArgs = predicate.args.filter(
       (arg) =>
         !conditionsToRemove.some((cond) =>
-          areExpressionsEqual(arg as BasicExpression<boolean>, cond)
-        )
+          areExpressionsEqual(arg as BasicExpression<boolean>, cond),
+        ),
     )
 
     if (remainingArgs.length === 0) {
@@ -940,7 +995,7 @@ function removeConditions(
  * Flattens nested AND operations to avoid unnecessary nesting.
  */
 function combineConditions(
-  conditions: Array<BasicExpression<boolean>>
+  conditions: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> {
   if (conditions.length === 0) {
     return { type: `val`, value: true } as BasicExpression<boolean>
@@ -977,7 +1032,7 @@ function combineConditions(
 function findPredicateWithOperator(
   predicates: Array<BasicExpression<boolean>>,
   operator: string,
-  value: any
+  value: any,
 ): BasicExpression<boolean> | undefined {
   return predicates.find((p) => {
     if (p.type === `func`) {
@@ -1012,7 +1067,7 @@ function areExpressionsEqual(a: BasicExpression, b: BasicExpression): boolean {
       return false
     }
     return aFunc.args.every((arg, i) =>
-      areExpressionsEqual(arg, bFunc.args[i]!)
+      areExpressionsEqual(arg, bFunc.args[i]!),
     )
   }
 
@@ -1086,7 +1141,7 @@ function arrayIncludesWithSet(
   array: Array<any>,
   value: any,
   primitiveSet: Set<any> | null,
-  arrayIsAllPrimitives?: boolean
+  arrayIsAllPrimitives?: boolean,
 ): boolean {
   // Fast path: use pre-built Set for O(1) lookup
   if (primitiveSet) {
@@ -1124,7 +1179,7 @@ function minValue(a: any, b: any): any {
 
 function areCompareOptionsEqual(
   a: { direction?: `asc` | `desc`; [key: string]: any },
-  b: { direction?: `asc` | `desc`; [key: string]: any }
+  b: { direction?: `asc` | `desc`; [key: string]: any },
 ): boolean {
   // For now, just compare direction - could be enhanced for other options
   return a.direction === b.direction
@@ -1215,7 +1270,7 @@ function isComparisonSubset(
   subsetFunc: Func,
   subsetValue: any,
   supersetFunc: Func,
-  supersetValue: any
+  supersetValue: any,
 ): boolean {
   const subOp = subsetFunc.name
   const superOp = supersetFunc.name
@@ -1283,7 +1338,7 @@ function isComparisonSubset(
 }
 
 function groupPredicatesByField(
-  predicates: Array<BasicExpression<boolean>>
+  predicates: Array<BasicExpression<boolean>>,
 ): Map<string | null, Array<BasicExpression<boolean>>> {
   const groups = new Map<string | null, Array<BasicExpression<boolean>>>()
 
@@ -1310,7 +1365,7 @@ function groupPredicatesByField(
 }
 
 function unionSameFieldPredicates(
-  predicates: Array<BasicExpression<boolean>>
+  predicates: Array<BasicExpression<boolean>>,
 ): BasicExpression<boolean> | null {
   if (predicates.length === 1) {
     return predicates[0]!
@@ -1436,7 +1491,7 @@ function unionSameFieldPredicates(
           return (p as Func).name === `in`
         }
         return false
-      })!
+      })!,
     )
   }
 

package/src/query/subset-dedupe.ts

@@ -3,9 +3,9 @@ import {
   isWhereSubset,
   minusWherePredicates,
   unionWherePredicates,
-} from "./predicate-utils.js"
-import type { BasicExpression } from "./ir.js"
-import type { LoadSubsetOptions } from "../types.js"
+} from './predicate-utils.js'
+import type { BasicExpression } from './ir.js'
+import type { LoadSubsetOptions } from '../types.js'
 
 /**
  * Deduplicated wrapper for a loadSubset function.
@@ -34,7 +34,7 @@ import type { LoadSubsetOptions } from "../types.js"
 export class DeduplicatedLoadSubset {
   // The underlying loadSubset function to wrap
   private readonly _loadSubset: (
-    options: LoadSubsetOptions
+    options: LoadSubsetOptions,
   ) => true | Promise<void>
 
   // An optional callback function that is invoked when a loadSubset call is deduplicated.
@@ -101,7 +101,7 @@ export class DeduplicatedLoadSubset {
     // Check against limited calls
     if (options.limit !== undefined) {
       const alreadyLoaded = this.limitedCalls.some((loaded) =>
-        isPredicateSubset(options, loaded)
+        isPredicateSubset(options, loaded),
       )
 
       if (alreadyLoaded) {
@@ -113,7 +113,7 @@ export class DeduplicatedLoadSubset {
     // Check against in-flight calls using the same subset logic as resolved calls
     // This prevents duplicate requests when concurrent calls have subset relationships
     const matchingInflight = this.inflightCalls.find((inflight) =>
-      isPredicateSubset(options, inflight.options)
+      isPredicateSubset(options, inflight.options),
     )
 
     if (matchingInflight !== undefined) {

package/src/scheduler.ts

@@ -54,7 +54,7 @@ export class Scheduler {
    * Get or create the state bucket for a context.
    */
   private getOrCreateContext(
-    contextId: SchedulerContextId
+    contextId: SchedulerContextId,
   ): SchedulerContextState {
     let context = this.contexts.get(contextId)
     if (!context) {
@@ -166,8 +166,8 @@ export class Scheduler {
       if (!ranThisPass) {
         throw new Error(
           `Scheduler detected unresolved dependencies for context ${String(
-            contextId
-          )}.`
+            contextId,
+          )}.`,
         )
       }
     }

package/src/strategies/debounceStrategy.ts

@@ -1,6 +1,6 @@
-import { LiteDebouncer } from "@tanstack/pacer-lite/lite-debouncer"
-import type { DebounceStrategy, DebounceStrategyOptions } from "./types"
-import type { Transaction } from "../transactions"
+import { LiteDebouncer } from '@tanstack/pacer-lite/lite-debouncer'
+import type { DebounceStrategy, DebounceStrategyOptions } from './types'
+import type { Transaction } from '../transactions'
 
 /**
  * Creates a debounce strategy that delays transaction execution until after
@@ -26,18 +26,18 @@ import type { Transaction } from "../transactions"
  * ```
  */
 export function debounceStrategy(
-  options: DebounceStrategyOptions
+  options: DebounceStrategyOptions,
 ): DebounceStrategy {
   const debouncer = new LiteDebouncer(
     (callback: () => Transaction) => callback(),
-    options
+    options,
   )
 
   return {
     _type: `debounce`,
     options,
     execute: <T extends object = Record<string, unknown>>(
-      fn: () => Transaction<T>
+      fn: () => Transaction<T>,
     ) => {
       debouncer.maybeExecute(fn as () => Transaction)
     },

package/src/strategies/index.ts

@@ -1,7 +1,7 @@
 // Export all strategy factories
-export { debounceStrategy } from "./debounceStrategy"
-export { queueStrategy } from "./queueStrategy"
-export { throttleStrategy } from "./throttleStrategy"
+export { debounceStrategy } from './debounceStrategy'
+export { queueStrategy } from './queueStrategy'
+export { throttleStrategy } from './throttleStrategy'
 
 // Export strategy types
 export type {
@@ -14,4 +14,4 @@ export type {
   ThrottleStrategy,
   ThrottleStrategyOptions,
   StrategyOptions,
-} from "./types"
+} from './types'

package/src/strategies/queueStrategy.ts

@@ -1,6 +1,6 @@
-import { LiteQueuer } from "@tanstack/pacer-lite/lite-queuer"
-import type { QueueStrategy, QueueStrategyOptions } from "./types"
-import type { Transaction } from "../transactions"
+import { LiteQueuer } from '@tanstack/pacer-lite/lite-queuer'
+import type { QueueStrategy, QueueStrategyOptions } from './types'
+import type { Transaction } from '../transactions'
 
 /**
  * Creates a queue strategy that processes all mutations in order with proper serialization.
@@ -71,14 +71,14 @@ export function queueStrategy(options?: QueueStrategyOptions): QueueStrategy {
       addItemsTo: options?.addItemsTo ?? `back`, // Default FIFO: add to back
       getItemsFrom: options?.getItemsFrom ?? `front`, // Default FIFO: get from front
       started: true, // Start processing immediately
-    }
+    },
   )
 
   return {
     _type: `queue`,
     options,
     execute: <T extends object = Record<string, unknown>>(
-      fn: () => Transaction<T>
+      fn: () => Transaction<T>,
     ) => {
       // Add the transaction-creating function to the queue
       queuer.addItem(fn as () => Transaction)

package/src/strategies/throttleStrategy.ts

@@ -1,6 +1,6 @@
-import { LiteThrottler } from "@tanstack/pacer-lite/lite-throttler"
-import type { ThrottleStrategy, ThrottleStrategyOptions } from "./types"
-import type { Transaction } from "../transactions"
+import { LiteThrottler } from '@tanstack/pacer-lite/lite-throttler'
+import type { ThrottleStrategy, ThrottleStrategyOptions } from './types'
+import type { Transaction } from '../transactions'
 
 /**
  * Creates a throttle strategy that ensures transactions are evenly spaced
@@ -46,18 +46,18 @@ import type { Transaction } from "../transactions"
  * ```
  */
 export function throttleStrategy(
-  options: ThrottleStrategyOptions
+  options: ThrottleStrategyOptions,
 ): ThrottleStrategy {
   const throttler = new LiteThrottler(
     (callback: () => Transaction) => callback(),
-    options
+    options,
   )
 
   return {
     _type: `throttle`,
     options,
     execute: <T extends object = Record<string, unknown>>(
-      fn: () => Transaction<T>
+      fn: () => Transaction<T>,
     ) => {
       throttler.maybeExecute(fn as () => Transaction)
     },

package/src/strategies/types.ts

@@ -1,4 +1,4 @@
-import type { Transaction } from "../transactions"
+import type { Transaction } from '../transactions'
 
 /**
  * Base strategy interface that all strategy implementations must conform to
@@ -13,7 +13,7 @@ export interface BaseStrategy<TName extends string = string> {
    * @returns The result of the function execution (if applicable)
    */
   execute: <T extends object = Record<string, unknown>>(
-    fn: () => Transaction<T>
+    fn: () => Transaction<T>,
   ) => void | Promise<void>
 
   /**

package/src/transactions.ts

@@ -1,20 +1,20 @@
-import { createDeferred } from "./deferred"
-import "./duplicate-instance-check"
+import { createDeferred } from './deferred'
+import './duplicate-instance-check'
 import {
   MissingMutationFunctionError,
   TransactionAlreadyCompletedRollbackError,
   TransactionNotPendingCommitError,
   TransactionNotPendingMutateError,
-} from "./errors"
-import { transactionScopedScheduler } from "./scheduler.js"
-import type { Deferred } from "./deferred"
+} from './errors'
+import { transactionScopedScheduler } from './scheduler.js'
+import type { Deferred } from './deferred'
 import type {
   MutationFn,
   PendingMutation,
   TransactionConfig,
   TransactionState,
   TransactionWithMutations,
-} from "./types"
+} from './types'
 
 const transactions: Array<Transaction<any>> = []
 let transactionStack: Array<Transaction<any>> = []
@@ -41,7 +41,7 @@ let sequenceNumber = 0
  */
 function mergePendingMutations<T extends object>(
   existing: PendingMutation<T>,
-  incoming: PendingMutation<T>
+  incoming: PendingMutation<T>,
 ): PendingMutation<T> | null {
   // Truth table implementation
   switch (`${existing.type}-${incoming.type}` as const) {
@@ -154,7 +154,7 @@ function mergePendingMutations<T extends object>(
  * await tx.commit()
  */
 export function createTransaction<T extends object = Record<string, unknown>>(
-  config: TransactionConfig<T>
+  config: TransactionConfig<T>,
 ): Transaction<T> {
   const newTransaction = new Transaction<T>(config)
   transactions.push(newTransaction)
@@ -327,7 +327,7 @@ class Transaction<T extends object = Record<string, unknown>> {
   applyMutations(mutations: Array<PendingMutation<any>>): void {
     for (const newMutation of mutations) {
       const existingIndex = this.mutations.findIndex(
-        (m) => m.globalKey === newMutation.globalKey
+        (m) => m.globalKey === newMutation.globalKey,
       )
 
       if (existingIndex >= 0) {