@livestore/common 0.0.0-snapshot-f5ece014485b5ab43795c218f7ba7cfa32c81707 → 0.0.0-snapshot-057a9e3a18ca69a310d4eb8cf35a34e94fa1841e

package/src/schema/EventDef.ts

@@ -28,7 +28,9 @@ export type EventDef<TName extends string, TType, TEncoded = TType, TDerived ext
   }
 
   /** Helper function to construct a partial event */
-  (args: TType): {
+  (
+    args: TType,
+  ): {
     name: TName
     args: TType
   }
@@ -194,14 +196,14 @@ export type Materializer<TEventDef extends EventDef.AnyWithoutFn = EventDef.AnyW
 ) => SingleOrReadonlyArray<MaterializerResult>
 
 export const defineMaterializer = <TEventDef extends EventDef.AnyWithoutFn>(
-  eventDef: TEventDef,
+  _eventDef: TEventDef,
   materializer: Materializer<TEventDef>,
 ): Materializer<TEventDef> => {
   return materializer
 }
 
 export const materializers = <TInputRecord extends Record<string, EventDef.AnyWithoutFn>>(
-  eventDefRecord: TInputRecord,
+  _eventDefRecord: TInputRecord,
   handlers: {
     [TEventName in TInputRecord[keyof TInputRecord]['name'] as Extract<
       TInputRecord[keyof TInputRecord],

package/src/schema/EventSequenceNumber.test.ts

@@ -4,9 +4,126 @@ import { expect } from 'vitest'
 import { EventSequenceNumber } from './mod.js'
 
 Vitest.describe('EventSequenceNumber', () => {
-  Vitest.test('nextPair', () => {
+  Vitest.test('nextPair (no rebase)', () => {
     const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
-    expect(EventSequenceNumber.nextPair(e_0_0, false).seqNum).toStrictEqual({ global: 1, client: 0 })
-    expect(EventSequenceNumber.nextPair(e_0_0, true).seqNum).toStrictEqual({ global: 0, client: 1 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: false }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 0,
+    })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: true }).seqNum).toStrictEqual({
+      global: 0,
+      client: 1,
+      rebaseGeneration: 0,
+    })
+  })
+
+  Vitest.test('nextPair (rebase)', () => {
+    const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: false, rebaseGeneration: 1 }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 1,
+    })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: true, rebaseGeneration: 1 }).seqNum).toStrictEqual({
+      global: 0,
+      client: 1,
+      rebaseGeneration: 1,
+    })
+
+    const e_0_0_g1 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 2 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0_g1, isClient: false }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 2,
+    })
+  })
+
+  Vitest.test('toString', () => {
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 0 }))).toBe('e0')
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 }))).toBe(
+      'e0r1',
+    )
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 1 }))).toBe('e0+1')
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 }))).toBe(
+      'e0+1r1',
+    )
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 5, client: 3, rebaseGeneration: 2 }))).toBe(
+      'e5+3r2',
+    )
+  })
+
+  Vitest.test('fromString', () => {
+    // Basic cases
+    expect(EventSequenceNumber.fromString('e0')).toStrictEqual(EventSequenceNumber.make({ global: 0, client: 0 }))
+    expect(EventSequenceNumber.fromString('e0r1')).toStrictEqual(
+      EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 }),
+    )
+    expect(EventSequenceNumber.fromString('e0+1')).toStrictEqual(EventSequenceNumber.make({ global: 0, client: 1 }))
+    expect(EventSequenceNumber.fromString('e0+1r1')).toStrictEqual(
+      EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 }),
+    )
+    expect(EventSequenceNumber.fromString('e5+3r2')).toStrictEqual(
+      EventSequenceNumber.make({ global: 5, client: 3, rebaseGeneration: 2 }),
+    )
+
+    // Error cases
+    expect(() => EventSequenceNumber.fromString('0')).toThrow(
+      'Invalid event sequence number string: must start with "e"',
+    )
+    expect(() => EventSequenceNumber.fromString('eabc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+    expect(() => EventSequenceNumber.fromString('e0+abc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+    expect(() => EventSequenceNumber.fromString('e0rabc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+  })
+
+  Vitest.test('toString/fromString roundtrip', () => {
+    const testCases = [
+      { global: 0, client: 0, rebaseGeneration: 0 },
+      { global: 0, client: 0, rebaseGeneration: 1 },
+      { global: 0, client: 1, rebaseGeneration: 0 },
+      { global: 0, client: 1, rebaseGeneration: 1 },
+      { global: 5, client: 3, rebaseGeneration: 2 },
+      { global: 100, client: 50, rebaseGeneration: 10 },
+    ]
+
+    for (const testCase of testCases) {
+      const original = EventSequenceNumber.make(testCase)
+      const str = EventSequenceNumber.toString(original)
+      const parsed = EventSequenceNumber.fromString(str)
+      expect(parsed).toStrictEqual(original)
+    }
+  })
+
+  Vitest.test('compare', () => {
+    const e_0_0_r0 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 0 })
+    const e_0_0_r1 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 })
+    const e_0_1_r0 = EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 0 })
+    const e_0_1_r1 = EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 })
+    const e_1_0_r0 = EventSequenceNumber.make({ global: 1, client: 0, rebaseGeneration: 0 })
+    const e_1_1_r0 = EventSequenceNumber.make({ global: 1, client: 1, rebaseGeneration: 0 })
+
+    // Global comparison (strongest level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_1_0_r0)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_1_0_r0, e_0_0_r0)).toBeGreaterThan(0)
+    expect(EventSequenceNumber.compare(e_0_1_r1, e_1_0_r0)).toBeLessThan(0) // global overrides client and rebase
+
+    // Client comparison (second level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_1_r0)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_0_1_r0, e_0_0_r0)).toBeGreaterThan(0)
+    expect(EventSequenceNumber.compare(e_0_0_r1, e_0_1_r0)).toBeLessThan(0) // client overrides rebase
+
+    // Rebase generation comparison (weakest level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_0_r1)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_0_0_r1, e_0_0_r0)).toBeGreaterThan(0)
+
+    // Equal comparison
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_0_r0)).toBe(0)
+    expect(EventSequenceNumber.compare(e_1_1_r0, e_1_1_r0)).toBe(0)
   })
 })

package/src/schema/EventSequenceNumber.ts

@@ -10,6 +10,8 @@ export const GlobalEventSequenceNumber = Schema.fromBrand(globalEventSequenceNum
 
 export const clientDefault = 0 as any as ClientEventSequenceNumber
 
+export const rebaseGenerationDefault = 0
+
 /**
  * LiveStore event sequence number value consisting of a globally unique event sequence number
  * and a client sequence number.
@@ -20,16 +22,17 @@ export type EventSequenceNumber = {
   global: GlobalEventSequenceNumber
   client: ClientEventSequenceNumber
   /**
-   * TODO add generation number in favour of LEADER_MERGE_COUNTER_TABLE
+   * Generation integer that is incremented whenever the client rebased.
+   * Starts from and resets to 0 for each global sequence number.
    */
-  // generation: number
+  rebaseGeneration: number
 }
 
-// export const EventSequenceNumber = Schema.Struct({})
-// export const EventSequenceNumber = Schema.Struct({})
-// export const ClientEventSequenceNumber = Schema.Struct({})
-// export const GlobalEventSequenceNumber = Schema.Struct({})
+export type EventSequenceNumberInput =
+  | EventSequenceNumber
+  | (Omit<typeof EventSequenceNumber.Encoded, 'rebaseGeneration'> & { rebaseGeneration?: number })
 
+// TODO adjust name to `ClientEventSequenceNumber`
 /**
  * NOTE: Client mutation events with a non-0 client id, won't be synced to the sync backend.
  */
@@ -40,36 +43,83 @@ export const EventSequenceNumber = Schema.Struct({
 
   // TODO also provide a way to see "confirmation level" of event (e.g. confirmed by leader/sync backend)
 
-  // TODO: actually add this field
   // Client only
-  // generation: Schema.Number.pipe(Schema.optional),
-}).annotations({ title: 'LiveStore.EventSequenceNumber' })
+  rebaseGeneration: Schema.Int,
+}).annotations({
+  title: 'LiveStore.EventSequenceNumber',
+  pretty: () => (seqNum) => toString(seqNum),
+})
 
 /**
  * Compare two event sequence numbers i.e. checks if the first event sequence number is less than the second.
+ * Comparison hierarchy: global > client > rebaseGeneration
  */
 export const compare = (a: EventSequenceNumber, b: EventSequenceNumber) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.client - b.client
+  if (a.client !== b.client) {
+    return a.client - b.client
+  }
+  return a.rebaseGeneration - b.rebaseGeneration
 }
 
 /**
  * Convert an event sequence number to a string representation.
  */
-export const toString = (seqNum: EventSequenceNumber) =>
-  seqNum.client === 0 ? `e${seqNum.global}` : `e${seqNum.global}+${seqNum.client}`
+export const toString = (seqNum: EventSequenceNumber) => {
+  const rebaseGenerationStr = seqNum.rebaseGeneration > 0 ? `r${seqNum.rebaseGeneration}` : ''
+  return seqNum.client === 0
+    ? `e${seqNum.global}${rebaseGenerationStr}`
+    : `e${seqNum.global}+${seqNum.client}${rebaseGenerationStr}`
+}
 
 /**
  * Convert a string representation of an event sequence number to an event sequence number.
+ * Parses strings in the format: e{global}[+{client}][r{rebaseGeneration}]
+ * Examples: "e0", "e0r1", "e0+1", "e0+1r1"
  */
 export const fromString = (str: string): EventSequenceNumber => {
-  const [global, client] = str.slice(1, -1).split(',').map(Number)
-  if (global === undefined || client === undefined) {
-    throw new Error('Invalid event sequence number string')
+  if (!str.startsWith('e')) {
+    throw new Error('Invalid event sequence number string: must start with "e"')
+  }
+
+  // Remove the 'e' prefix
+  const remaining = str.slice(1)
+
+  // Parse rebase generation if present
+  let rebaseGeneration = rebaseGenerationDefault
+  let withoutRebase = remaining
+  const rebaseMatch = remaining.match(/r(\d+)$/)
+  if (rebaseMatch !== null) {
+    rebaseGeneration = Number.parseInt(rebaseMatch[1]!, 10)
+    withoutRebase = remaining.slice(0, -rebaseMatch[0].length)
+  }
+
+  // Parse global and client parts
+  const parts = withoutRebase.split('+')
+
+  // Validate that parts contain only digits (and possibly empty for client)
+  if (parts[0] === '' || !/^\d+$/.test(parts[0]!)) {
+    throw new Error('Invalid event sequence number string: invalid number format')
+  }
+
+  if (parts.length > 1 && parts[1] !== undefined && (parts[1] === '' || !/^\d+$/.test(parts[1]))) {
+    throw new Error('Invalid event sequence number string: invalid number format')
+  }
+
+  const global = Number.parseInt(parts[0]!, 10)
+  const client = parts.length > 1 && parts[1] !== undefined ? Number.parseInt(parts[1], 10) : 0
+
+  if (Number.isNaN(global) || Number.isNaN(client) || Number.isNaN(rebaseGeneration)) {
+    throw new TypeError('Invalid event sequence number string: invalid number format')
+  }
+
+  return {
+    global: global as any as GlobalEventSequenceNumber,
+    client: client as any as ClientEventSequenceNumber,
+    rebaseGeneration,
   }
-  return { global, client } as EventSequenceNumber
 }
 
 export const isEqual = (a: EventSequenceNumber, b: EventSequenceNumber) =>
@@ -80,6 +130,7 @@ export type EventSequenceNumberPair = { seqNum: EventSequenceNumber; parentSeqNu
 export const ROOT = {
   global: 0 as any as GlobalEventSequenceNumber,
   client: clientDefault,
+  rebaseGeneration: rebaseGenerationDefault,
 } satisfies EventSequenceNumber
 
 export const isGreaterThan = (a: EventSequenceNumber, b: EventSequenceNumber) => {
@@ -101,21 +152,42 @@ export const diff = (a: EventSequenceNumber, b: EventSequenceNumber) => {
   }
 }
 
-export const make = (seqNum: EventSequenceNumber | typeof EventSequenceNumber.Encoded): EventSequenceNumber => {
-  return Schema.is(EventSequenceNumber)(seqNum) ? seqNum : Schema.decodeSync(EventSequenceNumber)(seqNum)
+export const make = (seqNum: EventSequenceNumberInput): EventSequenceNumber => {
+  return Schema.is(EventSequenceNumber)(seqNum)
+    ? seqNum
+    : Schema.decodeSync(EventSequenceNumber)({
+        ...seqNum,
+        rebaseGeneration: seqNum.rebaseGeneration ?? rebaseGenerationDefault,
+      })
 }
 
-export const nextPair = (seqNum: EventSequenceNumber, isLocal: boolean): EventSequenceNumberPair => {
-  if (isLocal) {
+export const nextPair = ({
+  seqNum,
+  isClient,
+  rebaseGeneration,
+}: {
+  seqNum: EventSequenceNumber
+  isClient: boolean
+  rebaseGeneration?: number
+}): EventSequenceNumberPair => {
+  if (isClient) {
     return {
-      seqNum: { global: seqNum.global, client: (seqNum.client + 1) as any as ClientEventSequenceNumber },
+      seqNum: {
+        global: seqNum.global,
+        client: (seqNum.client + 1) as any as ClientEventSequenceNumber,
+        rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
+      },
       parentSeqNum: seqNum,
     }
   }
 
   return {
-    seqNum: { global: (seqNum.global + 1) as any as GlobalEventSequenceNumber, client: clientDefault },
+    seqNum: {
+      global: (seqNum.global + 1) as any as GlobalEventSequenceNumber,
+      client: clientDefault,
+      rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
+    },
     // NOTE we always point to `client: 0` for non-clientOnly events
-    parentSeqNum: { global: seqNum.global, client: clientDefault },
+    parentSeqNum: { global: seqNum.global, client: clientDefault, rebaseGeneration: seqNum.rebaseGeneration },
   }
 }

package/src/schema/LiveStoreEvent.ts

@@ -221,10 +221,18 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
    *          +---- global number
    * Client num is ommitted for global events
    */
-  rebase = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, isClient: boolean) =>
+  rebase = ({
+    parentSeqNum,
+    isClient,
+    rebaseGeneration,
+  }: {
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    isClient: boolean
+    rebaseGeneration: number
+  }) =>
     new EncodedWithMeta({
       ...this,
-      ...EventSequenceNumber.nextPair(parentSeqNum, isClient),
+      ...EventSequenceNumber.nextPair({ seqNum: parentSeqNum, isClient, rebaseGeneration }),
     })
 
   static fromGlobal = (
@@ -237,8 +245,16 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
   ) =>
     new EncodedWithMeta({
       ...event,
-      seqNum: { global: event.seqNum, client: EventSequenceNumber.clientDefault },
-      parentSeqNum: { global: event.parentSeqNum, client: EventSequenceNumber.clientDefault },
+      seqNum: {
+        global: event.seqNum,
+        client: EventSequenceNumber.clientDefault,
+        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      },
+      parentSeqNum: {
+        global: event.parentSeqNum,
+        client: EventSequenceNumber.clientDefault,
+        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      },
       meta: {
         sessionChangeset: { _tag: 'unset' as const },
         syncMetadata: meta.syncMetadata,

package/src/schema/events.ts

@@ -1 +1 @@
-export { defineEvent, synced, clientOnly } from './EventDef.js'
+export { clientOnly, defineEvent, synced } from './EventDef.js'

package/src/schema/mod.ts

@@ -1,9 +1,9 @@
-export * as SystemTables from './state/sqlite/system-tables.js'
-export { SqliteAst, SqliteDsl } from './state/sqlite/db-schema/mod.js'
 export * from './EventDef.js'
-export * from './state/sqlite/schema-helpers.js'
-export * from './schema.js'
-export * as State from './state/mod.js'
-export * as LiveStoreEvent from './LiveStoreEvent.js'
 export * as EventSequenceNumber from './EventSequenceNumber.js'
 export * as Events from './events.js'
+export * as LiveStoreEvent from './LiveStoreEvent.js'
+export * from './schema.js'
+export * as State from './state/mod.js'
+export { SqliteAst, SqliteDsl } from './state/sqlite/db-schema/mod.js'
+export * from './state/sqlite/schema-helpers.js'
+export * as SystemTables from './state/sqlite/system-tables.js'

package/src/schema/state/sqlite/client-document-def.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from 'vitest'
 
 import { tables } from '../../../__tests__/fixture.js'
 import type * as LiveStoreEvent from '../../LiveStoreEvent.js'
-import { clientDocument, ClientDocumentTableDefSymbol } from './client-document-def.js'
+import { ClientDocumentTableDefSymbol, clientDocument } from './client-document-def.js'
 
 describe('client document table', () => {
   test('set event', () => {
@@ -70,8 +70,9 @@ describe('client document table', () => {
     })
 
     test('struct value (partial set=true)', () => {
-      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: true }))
-        .toMatchInlineSnapshot(`
+      expect(
+        forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: true }),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "id1",
@@ -92,8 +93,9 @@ describe('client document table', () => {
     })
 
     test('struct value (partial set=false)', () => {
-      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: false }))
-        .toMatchInlineSnapshot(`
+      expect(
+        forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: false }),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "id1",

package/src/schema/state/sqlite/client-document-def.ts

@@ -386,37 +386,49 @@ export namespace ClientDocumentTableDef {
     }
   }
 
-  export type GetOptions<TTableDef extends TraitAny> =
-    TTableDef extends ClientDocumentTableDef.Trait<any, any, any, infer TOptions> ? TOptions : never
+  export type GetOptions<TTableDef extends TraitAny> = TTableDef extends ClientDocumentTableDef.Trait<
+    any,
+    any,
+    any,
+    infer TOptions
+  >
+    ? TOptions
+    : never
 
   export type TraitAny = Trait<any, any, any, any>
 
-  export type DefaultIdType<TTableDef extends TraitAny> =
-    TTableDef extends ClientDocumentTableDef.Trait<any, any, any, infer TOptions>
-      ? TOptions['default']['id'] extends SessionIdSymbol | string
-        ? TOptions['default']['id']
-        : never
+  export type DefaultIdType<TTableDef extends TraitAny> = TTableDef extends ClientDocumentTableDef.Trait<
+    any,
+    any,
+    any,
+    infer TOptions
+  >
+    ? TOptions['default']['id'] extends SessionIdSymbol | string
+      ? TOptions['default']['id']
       : never
+    : never
 
-  export type SetEventDefLike<TName extends string, TType, TOptions extends ClientDocumentTableOptions<TType>> =
-    // Helper to create partial event
-    (TOptions['default']['id'] extends undefined
-      ? (
-          args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
-          id: string | SessionIdSymbol,
-        ) => { name: `${TName}Set`; args: { id: string; value: TType } }
-      : (
-          args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
-          id?: string | SessionIdSymbol,
-        ) => { name: `${TName}Set`; args: { id: string; value: TType } }) & {
+  export type SetEventDefLike<
+    TName extends string,
+    TType,
+    TOptions extends ClientDocumentTableOptions<TType>,
+  > = (TOptions['default']['id'] extends undefined // Helper to create partial event
+    ? (
+        args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
+        id: string | SessionIdSymbol,
+      ) => { name: `${TName}Set`; args: { id: string; value: TType } }
+    : (
+        args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
+        id?: string | SessionIdSymbol,
+      ) => { name: `${TName}Set`; args: { id: string; value: TType } }) & {
+    readonly name: `${TName}Set`
+    readonly schema: Schema.Schema<any>
+    readonly Event: {
       readonly name: `${TName}Set`
-      readonly schema: Schema.Schema<any>
-      readonly Event: {
-        readonly name: `${TName}Set`
-        readonly args: { id: string; value: TType }
-      }
-      readonly options: { derived: true; clientOnly: true; facts: undefined }
+      readonly args: { id: string; value: TType }
     }
+    readonly options: { derived: true; clientOnly: true; facts: undefined }
+  }
 
   export type SetEventDef<TName extends string, TType, TOptions extends ClientDocumentTableOptions<TType>> = EventDef<
     TName,

package/src/schema/state/sqlite/db-schema/dsl/field-defs.ts

@@ -17,7 +17,7 @@ export const isColumnDefinition = (value: unknown): value is ColumnDefinition<an
     typeof value === 'object' &&
     value !== null &&
     'columnType' in value &&
-    validColumnTypes.includes(value['columnType'] as any)
+    validColumnTypes.includes(value.columnType as any)
   )
 }
 
@@ -36,7 +36,7 @@ export type SqlDefaultValue = {
 }
 
 export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
-  return typeof value === 'object' && value !== null && 'sql' in value && typeof value['sql'] === 'string'
+  return typeof value === 'object' && value !== null && 'sql' in value && typeof value.sql === 'string'
 }
 
 export type ColDefFn<TColumnType extends FieldColumnType> = {

package/src/schema/state/sqlite/db-schema/dsl/mod.ts

@@ -19,12 +19,13 @@ export type DbSchemaInput = Record<string, TableDefinition<any, any>> | Readonly
  * - array: we use the table name of each array item (= table definition) as the object key
  * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
  */
-export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
-  TSchemaInput extends ReadonlyArray<TableDefinition<any, any>>
-    ? { [K in TSchemaInput[number] as K['name']]: K }
-    : TSchemaInput extends Record<string, TableDefinition<any, any>>
-      ? { [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K] }
-      : never
+export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> = TSchemaInput extends ReadonlyArray<
+  TableDefinition<any, any>
+>
+  ? { [K in TSchemaInput[number] as K['name']]: K }
+  : TSchemaInput extends Record<string, TableDefinition<any, any>>
+    ? { [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K] }
+    : never
 
 // TODO ensure via runtime check (possibly even via type-level check) that all index names are unique
 export const makeDbSchema = <TDbSchemaInput extends DbSchemaInput>(
@@ -113,8 +114,12 @@ export type TableDefinition<TName extends string, TColumns extends Columns> = {
 
 export type Columns = Record<string, ColumnDefinition<any, any>>
 
-export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> =
-  TColumns extends ColumnDefinition<any, any> ? true : false
+export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> = TColumns extends ColumnDefinition<
+  any,
+  any
+>
+  ? true
+  : false
 
 /**
  * NOTE this is only needed to avoid a TS limitation where `StructSchemaForColumns` in the default case
@@ -207,8 +212,9 @@ export namespace FromColumns {
 
   export type RequiredInsertColumnNames<TColumns extends Columns> = keyof RequiredInsertColumns<TColumns>
 
-  export type RequiresInsertValues<TColumns extends Columns> =
-    RequiredInsertColumnNames<TColumns> extends never ? false : true
+  export type RequiresInsertValues<TColumns extends Columns> = RequiredInsertColumnNames<TColumns> extends never
+    ? false
+    : true
 
   export type InsertRowDecoded<TColumns extends Columns> = Types.Simplify<
     Pick<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &

package/src/schema/state/sqlite/db-schema/hash.ts

@@ -1,11 +1,10 @@
 // Based on https://stackoverflow.com/a/7616484
 export const hashCode = (str: string) => {
-  let hash = 0,
-    i,
-    chr
+  let hash = 0
+  let i: number
+  let chr: number
   if (str.length === 0) return hash
   for (i = 0; i < str.length; i++) {
-    // eslint-disable-next-line unicorn/prefer-code-point
     chr = str.charCodeAt(i)
     hash = (hash << 5) - hash + chr
     hash = Math.trunc(hash) // Convert to 32bit integer

package/src/schema/state/sqlite/db-schema/mod.ts

@@ -1,2 +1,2 @@
-export * as SqliteDsl from './dsl/mod.js'
 export * as SqliteAst from './ast/sqlite.js'
+export * as SqliteDsl from './dsl/mod.js'

package/src/schema/state/sqlite/mod.ts

@@ -6,17 +6,17 @@ import type { InternalState } from '../../schema.js'
 import { ClientDocumentTableDefSymbol, tableIsClientDocumentTable } from './client-document-def.js'
 import { SqliteAst } from './db-schema/mod.js'
 import { stateSystemTables } from './system-tables.js'
-import { type TableDef, type TableDefBase } from './table-def.js'
+import type { TableDef, TableDefBase } from './table-def.js'
 
-export * from './table-def.js'
+export * from '../../EventDef.js'
 export {
-  ClientDocumentTableDefSymbol,
-  tableIsClientDocumentTable,
-  clientDocument,
   type ClientDocumentTableDef,
+  ClientDocumentTableDefSymbol,
   type ClientDocumentTableOptions,
+  clientDocument,
+  tableIsClientDocumentTable,
 } from './client-document-def.js'
-export * from '../../EventDef.js'
+export * from './table-def.js'
 
 export const makeState = <TStateInput extends InputState>(inputSchema: TStateInput): InternalState => {
   const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)