@livestore/common 0.4.0 → 0.5.0-dev.1

package/src/schema/state/sqlite/column-def.ts

@@ -12,19 +12,19 @@ import { SqliteDsl } from './db-schema/mod.ts'
  * Fields with both null and undefined will emit a warning as this is a lossy conversion.
  */
 export const getColumnDefForSchema = (
-  schema: Schema.Schema.AnyNoContext,
+  schema: Schema.Top,
   propertySignature?: SchemaAST.PropertySignature,
   forceNullable = false,
 ): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
 
   // Extract annotations
-  const getAnnotation = <T>(annotationId: symbol): Option.Option<T> =>
+  const getAnnotation = <T>(annotationId: string): Option.Option<T> =>
     propertySignature !== undefined
       ? hasPropertyAnnotation<T>(propertySignature, annotationId)
-      : SchemaAST.getAnnotation<T>(annotationId)(ast)
+      : Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(ast))
 
-  const columnType = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
+  const columnType = Option.fromUndefinedOr(SchemaAST.resolveAt<SqliteDsl.FieldColumnType>(ColumnType)(ast))
 
   // Check if schema has null (e.g., Schema.NullOr) or undefined or if it's forced nullable (optional field)
   const isNullable = forceNullable === true || hasNull(ast) === true || hasUndefined(ast) === true
@@ -50,13 +50,13 @@ export const getColumnDefForSchema = (
 
 const hasPropertyAnnotation = <T>(
   propertySignature: SchemaAST.PropertySignature,
-  annotationId: symbol,
+  annotationId: string,
 ): Option.Option<T> => {
-  if ('annotations' in propertySignature && propertySignature.annotations !== undefined) {
-    const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
-    if (Option.isSome(annotation) === true) return annotation
+  const keyAnnotation = propertySignature.type.context?.annotations?.[annotationId] as T | undefined
+  if (keyAnnotation !== undefined) {
+    return Option.some(keyAnnotation)
   }
-  return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
+  return Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(propertySignature.type))
 }
 
 /**
@@ -72,10 +72,11 @@ export const schemaFieldsToColumns = (
   for (const prop of propertySignatures) {
     if (typeof prop.name !== 'string') continue
 
-    const fieldSchema = Schema.make(prop.type)
+    const isOptional = SchemaAST.isOptional(prop.type)
+    const fieldSchema = Schema.make<Schema.Top>(prop.type)
 
     // Warn about lossy conversion for fields with both null and undefined
-    if (prop.isOptional === true) {
+    if (isOptional === true) {
       const { hasNull, hasUndefined } = checkNullUndefined(fieldSchema.ast)
       if (hasNull === true && hasUndefined === true) {
         console.warn(`Field '${prop.name}' has both null and undefined - treating | undefined as | null`)
@@ -83,7 +84,7 @@ export const schemaFieldsToColumns = (
     }
 
     // Get column definition - pass nullable flag for optional fields
-    const columnDef = getColumnDefForSchema(fieldSchema, prop, prop.isOptional === true)
+    const columnDef = getColumnDefForSchema(fieldSchema, prop, isOptional === true)
 
     // Check for primary key and unique annotations
     const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
@@ -112,8 +113,8 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
   let hasUndefined = false
 
   const visit = (type: SchemaAST.AST): void => {
-    if (SchemaAST.isUndefinedKeyword(type) === true) hasUndefined = true
-    else if (SchemaAST.isLiteral(type) === true && type.literal === null) hasNull = true
+    if (SchemaAST.isUndefined(type) === true) hasUndefined = true
+    else if (SchemaAST.isNull(type) === true) hasNull = true
     else if (SchemaAST.isUnion(type) === true) type.types.forEach(visit)
   }
 
@@ -122,7 +123,7 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
 }
 
 const hasNull = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isLiteral(ast) === true && ast.literal === null) return true
+  if (SchemaAST.isNull(ast) === true) return true
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasNull(type))
   }
@@ -130,7 +131,7 @@ const hasNull = (ast: SchemaAST.AST): boolean => {
 }
 
 const hasUndefined = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isUndefinedKeyword(ast) === true) return true
+  if (SchemaAST.isUndefined(ast) === true) return true
   if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasUndefined(type))
   }
@@ -152,36 +153,49 @@ const getColumnForType = (columnType: string, nullable = false): SqliteDsl.Colum
   }
 }
 
-const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false): SqliteDsl.ColumnDefinition.Any => {
+const getColumnForSchema = (schema: Schema.Top, nullable = false): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
   // Strip nullable wrapper to get core type
   const coreAst = stripNullable(ast)
-  const coreSchema = stripNullable(ast) === ast ? schema : Schema.make(coreAst)
+  const coreSchema = (stripNullable(ast) === ast ? schema : Schema.make(coreAst)) as Schema.Codec<any, any>
 
   // Special case: Boolean is transformed to integer in SQLite
-  if (SchemaAST.isBooleanKeyword(coreAst) === true) {
+  if (SchemaAST.isBoolean(coreAst) === true) {
     return SqliteDsl.boolean({ nullable })
   }
 
   // Get the encoded AST - what actually gets stored in SQLite
-  const encodedAst = Schema.encodedSchema(coreSchema).ast
+  const encodedAst = Schema.toEncoded(coreSchema).ast
+
+  // Adapt Date values on the encoded side to ISO text, then run the original
+  // codec so its checks and transformations are preserved in both directions.
+  if (hasDateRepresentation(stripNullable(encodedAst)) === true) {
+    const encodedNullable = hasNull(encodedAst)
+    const dateStorage = encodedNullable === true ? Schema.NullOr(Schema.DateFromString) : Schema.DateFromString
+    const adaptedSchema = dateStorage.pipe(Schema.decodeTo(coreSchema))
+    return {
+      ...SqliteDsl.text(),
+      schema: nullable === true ? Schema.NullOr(adaptedSchema) : adaptedSchema,
+      // Encoded nulls may decode to non-null values, so allow SQL NULL without
+      // bypassing the original codec's null transformation.
+      nullable: nullable === true || encodedNullable === true,
+    }
+  }
 
   // Check if the encoded type matches SQLite native types
-  if (SchemaAST.isStringKeyword(encodedAst) === true) {
+  if (SchemaAST.isString(encodedAst) === true) {
     return SqliteDsl.text({ schema: coreSchema, nullable })
   }
 
-  if (SchemaAST.isNumberKeyword(encodedAst) === true) {
-    // Special cases for integer columns
-    const id = SchemaAST.getIdentifierAnnotation(coreAst).pipe(Option.getOrElse(() => ''))
-    if (id === 'Int' || id === 'DateFromNumber') {
+  if (SchemaAST.isNumber(encodedAst) === true) {
+    if (hasCheck(coreAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(coreAst) === true) {
       return SqliteDsl.integer({ schema: coreSchema, nullable })
     }
     return SqliteDsl.real({ schema: coreSchema, nullable })
   }
 
   if (isUint8ArraySchema(coreAst) === true || isUint8ArraySchema(encodedAst) === true) {
-    return SqliteDsl.blob({ schema: Schema.Uint8ArrayFromSelf as Schema.Schema<Uint8Array<ArrayBuffer>>, nullable })
+    return SqliteDsl.blob({ schema: coreSchema, nullable })
   }
 
   const literalColumn = getLiteralColumnDefinition(encodedAst, coreSchema, nullable, coreAst)
@@ -200,7 +214,7 @@ const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
 
   // Filter out null/undefined members while preserving any annotations on the union
   const coreTypes = ast.types.filter(
-    (type) => !(SchemaAST.isLiteral(type) && type.literal === null) && !SchemaAST.isUndefinedKeyword(type),
+    (type) => SchemaAST.isNull(type) === false && SchemaAST.isUndefined(type) === false,
   )
 
   if (coreTypes.length === 0 || coreTypes.length === ast.types.length) {
@@ -211,12 +225,12 @@ const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
     return coreTypes[0]!
   }
 
-  return SchemaAST.Union.make(coreTypes, ast.annotations)
+  return new SchemaAST.Union(coreTypes, ast.options, ast.annotations)
 }
 
 const getLiteralColumnDefinition = (
   ast: SchemaAST.AST,
-  schema: Schema.Schema.AnyNoContext,
+  schema: Schema.Codec<any, any>,
   nullable: boolean,
   sourceAst: SchemaAST.AST,
 ): SqliteDsl.ColumnDefinition.Any | null => {
@@ -228,8 +242,7 @@ const getLiteralColumnDefinition = (
     case 'string':
       return SqliteDsl.text({ schema, nullable })
     case 'number': {
-      const id = SchemaAST.getIdentifierAnnotation(sourceAst).pipe(Option.getOrElse(() => ''))
-      if (id === 'Int' || id === 'DateFromNumber') {
+      if (hasCheck(sourceAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(sourceAst) === true) {
         return SqliteDsl.integer({ schema, nullable })
       }
 
@@ -247,6 +260,9 @@ const getLiteralColumnDefinition = (
   }
 }
 
+/** Effect's built-in date codecs expose their semantic type through the Date representation annotation. */
+const hasDateRepresentation = (ast: SchemaAST.AST): boolean => hasRepresentation(ast, 'effect/schema/Date')
+
 const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.LiteralValue> | null => {
   if (SchemaAST.isLiteral(ast) === true) return [ast.literal]
 
@@ -255,7 +271,7 @@ const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.Liter
     ast.types.length > 0 &&
     ast.types.every((type) => SchemaAST.isLiteral(type)) === true
   ) {
-    return ast.types.map((type) => (type as SchemaAST.Literal).literal)
+    return ast.types.map((type) => type.literal)
   }
 
   return null
@@ -264,7 +280,7 @@ const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.Liter
 const getLiteralValueType = (
   literals: ReadonlyArray<SchemaAST.LiteralValue>,
 ): 'string' | 'number' | 'boolean' | 'bigint' | null => {
-  const literalTypes = new Set(literals.map((value) => (value === null ? 'null' : typeof value)))
+  const literalTypes = new Set(literals.map((value) => typeof value))
   if (literalTypes.size !== 1) return null
 
   const [literalType] = literalTypes
@@ -273,15 +289,49 @@ const getLiteralValueType = (
     : null
 }
 
+/**
+ * Recursively checks for Effect built-in check metadata.
+ *
+ * Checks can be attached directly as `Filter`s or nested in `FilterGroup`s when
+ * schemas compose multiple refinements, e.g. `Schema.Int.check(...)`.
+ *
+ * Effect rc.109 replaced the closed `meta` annotation with the open `representation`
+ * identity, so built-in checks are matched by their representation id.
+ */
+const hasCheck = (checks: ReadonlyArray<SchemaAST.Check<unknown>> | undefined, representationId: string): boolean => {
+  return (
+    checks?.some((check) => {
+      switch (check._tag) {
+        case 'Filter':
+          return check.annotations?.representation?.id === representationId
+        case 'FilterGroup':
+          return hasCheck(check.checks, representationId)
+      }
+    }) === true
+  )
+}
+
 const isUint8ArraySchema = (ast: SchemaAST.AST): boolean => {
-  const identifier = SchemaAST.getIdentifierAnnotation(ast)
-  if (Option.isSome(identifier) === true && identifier.value.includes('Uint8Array') === true) {
+  // `resolveAt` reads the last check's annotations, which can mask the declaration's representation.
+  if (hasRepresentation(ast, 'effect/schema/Uint8Array') === true) {
+    return true
+  }
+
+  const identifier = SchemaAST.resolveIdentifier(ast)
+  if (identifier !== undefined && identifier.includes('Uint8Array') === true) {
     return true
   }
 
-  if (SchemaAST.isTupleType(ast) === true) {
-    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumberKeyword(ast.rest[0]!.type)
+  if (SchemaAST.isArrays(ast) === true) {
+    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumber(ast.rest[0]!)
   }
 
   return false
 }
+
+const hasRepresentation = (ast: SchemaAST.AST, id: string): boolean => {
+  const representation = ast.annotations?.representation
+  return (
+    typeof representation === 'object' && representation !== null && 'id' in representation && representation.id === id
+  )
+}

package/src/schema/state/sqlite/column-spec.test.ts

@@ -28,9 +28,9 @@ const createColumn = (
       case 'text':
         return Schema.String
       case 'integer':
-        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Number
+        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Finite
       case 'real':
-        return Schema.Number
+        return Schema.Finite
       case 'blob':
         return Schema.Uint8ArrayFromBase64
       default:

package/src/schema/state/sqlite/column-spec.ts

@@ -19,7 +19,7 @@ export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
   // is only valid on a single column declared as INTEGER PRIMARY KEY (column-level).
   const columnDefStrs = tableAst.columns.map((column) =>
     toSqliteColumnSpec(column, {
-      inlinePrimaryKey: hasSinglePk && column === pkColumn &&  column.primaryKey,
+      inlinePrimaryKey: hasSinglePk && column === pkColumn && column.primaryKey,
     }),
   )
 
@@ -40,7 +40,8 @@ const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey:
   const nullableStr = opts.inlinePrimaryKey === true ? '' : column.nullable === false ? 'not null' : ''
 
   // Only include AUTOINCREMENT when it's valid: single-column INTEGER PRIMARY KEY
-  const includeAutoIncrement = opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
+  const includeAutoIncrement =
+    opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
 
   const pkStr = opts.inlinePrimaryKey === true ? 'primary key' : ''
   const autoIncrementStr = includeAutoIncrement === true ? 'autoincrement' : ''

package/src/schema/state/sqlite/db-schema/ast/fingerprint-digest.ts

@@ -0,0 +1,6 @@
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { Base64Url } from '@livestore/utils/effect'
+
+/** Preserve every digest bit while staying inside the 56-character SQLite VFS filename limit. */
+export const digestToFingerprint = (bytes: Uint8Array): string => Base64Url.encode(sha256(bytes))

package/src/schema/state/sqlite/db-schema/ast/fingerprint.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, test } from 'vitest'
+
+import { Schema } from '@livestore/utils/effect'
+
+import { liveStoreStorageFormatVersion } from '../../../../../version.ts'
+import { makeState } from '../../mod.ts'
+import { REBUILD_META_TABLE } from '../../system-tables/state-tables.ts'
+import { SqliteDsl } from '../mod.ts'
+import { digestToFingerprint } from './fingerprint-digest.ts'
+import { fingerprint } from './fingerprint.ts'
+
+describe('SQLite storage fingerprints', () => {
+  test('pins the final fingerprint output', () => {
+    expect(fingerprint(makePhysicalTable().ast)).toBe('UnLwYzVBhwzPCK5q7TrPU3q2N0dTe8m_98bud8HsAs8')
+    expect(fingerprint(makeJsonTable('documents', representativeJsonSchema).ast)).toBe(
+      'kUzaurzV2rcXYLljHOZ64TDR9c_RebqD7y5ZUM_nPBE',
+    )
+    expect(fingerprint(makeJsonTable('documents', normalizedCheckIdsJsonSchema).ast)).toBe(
+      'I0XYuOUSYqWwG5Opxbc1u-TNNE3pFQCHzpBZ_ChYGaA',
+    )
+    expect(makeState({ tables: [], materializers: {} }).sqlite.hash).toBe('o8mmnRDnhXhkgDpBybM3FK7S-PkaLEj_pKcnbzgg3TU')
+  })
+
+  test('isolates pre-completion-marker state databases without changing the hash algorithm', () => {
+    const state = makeState({ tables: [], materializers: {} })
+    const legacyTables = [...state.sqlite.tables.values()]
+      .filter((table) => table.sqliteDef.name !== REBUILD_META_TABLE)
+      .map((table) => table.sqliteDef.ast)
+    const legacyHash = fingerprint({ _tag: 'dbSchema', tables: legacyTables })
+    expect(legacyHash).toBe('H5Uktp6Ffp84WDj_RWPnfDnaQEu_E61AMl7ieZ9Zn8k')
+    expect(state.sqlite.hash).not.toBe(legacyHash)
+  })
+
+  test('matches the standard SHA-256 vector', () => {
+    expect(digestToFingerprint(new TextEncoder().encode('abc'))).toBe('ungWv48Bz-pBQUDeXa4iI7ADYaOWF3qctBD_YfIAFa0')
+  })
+
+  test('keeps the full digest inside the Cloudflare VFS filename limit', () => {
+    const value = fingerprint(makePhysicalTable().ast)
+
+    expect(value).toHaveLength(43)
+    expect(`state${value}@${liveStoreStorageFormatVersion}.db`.length).toBeLessThanOrEqual(56)
+  })
+
+  test('is independent of table and index declaration order', () => {
+    const first = makeJsonTable('first', Schema.Struct({ value: Schema.String }))
+    const second = makeJsonTable('second', Schema.Struct({ value: Schema.Finite }))
+
+    expect(fingerprint({ _tag: 'dbSchema', tables: [first.ast, second.ast] })).toBe(
+      fingerprint({ _tag: 'dbSchema', tables: [second.ast, first.ast] }),
+    )
+
+    const table = SqliteDsl.table(
+      'indexed',
+      {
+        id: SqliteDsl.text({ primaryKey: true }),
+        age: SqliteDsl.integer(),
+      },
+      [
+        { name: 'indexed_by_age', columns: ['age'], isUnique: false },
+        { name: 'indexed_by_id', columns: ['id'], isUnique: true },
+      ],
+    ).ast
+    expect(fingerprint({ ...table, indexes: table.indexes.toReversed() })).toBe(fingerprint(table))
+  })
+
+  test('ignores Effect metadata that does not affect accepted encoded JSON', () => {
+    const plain = makeJsonTable('documents', Schema.Struct({ value: Schema.String }))
+    const annotated = makeJsonTable(
+      'documents',
+      Schema.Struct({ value: Schema.String }).annotate({ description: 'documentation only', title: 'Document' }),
+    )
+    const readonlyArray = makeJsonTable('documents', Schema.Array(Schema.String))
+    const mutableArray = makeJsonTable('documents', Schema.mutable(Schema.Array(Schema.String)))
+
+    expect(fingerprint(plain.ast)).toBe(fingerprint(annotated.ast))
+    expect(fingerprint(readonlyArray.ast)).toBe(fingerprint(mutableArray.ast))
+  })
+
+  test('changes when represented JSON checks change', () => {
+    const minimumTwo = makeJsonTable('documents', Schema.Struct({ value: Schema.String.check(Schema.isMinLength(2)) }))
+    const minimumThree = makeJsonTable(
+      'documents',
+      Schema.Struct({ value: Schema.String.check(Schema.isMinLength(3)) }),
+    )
+
+    expect(fingerprint(minimumTwo.ast)).not.toBe(fingerprint(minimumThree.ast))
+  })
+
+  test('distinguishes codecs with the same encoded primitive', () => {
+    const date = makeJsonTable('documents', Schema.Struct({ value: Schema.DateFromString }))
+    const string = makeJsonTable('documents', Schema.Struct({ value: Schema.String }))
+
+    expect(fingerprint(date.ast)).not.toBe(fingerprint(string.ast))
+  })
+
+  test('handles recursive JSON schemas deterministically', () => {
+    const first = makeJsonTable('trees', makeTreeSchema())
+    const second = makeJsonTable('trees', makeTreeSchema())
+
+    expect(fingerprint(first.ast)).toBe(fingerprint(second.ast))
+  })
+
+  test('supports opaque Effect schemas without persistence annotations', () => {
+    const OpaqueString = Schema.declare<string>((value): value is string => typeof value === 'string')
+    const table = makeJsonTable('opaque_documents', Schema.Struct({ value: OpaqueString }))
+
+    expect(() => fingerprint(table.ast)).not.toThrow()
+  })
+
+  test('keeps application-owned representation payload fields', () => {
+    const first = Schema.declare<string>((value): value is string => typeof value === 'string', {
+      representation: { id: 'example/opaque', payload: { annotations: 'first', isMutable: true } },
+    })
+    const second = Schema.declare<string>((value): value is string => typeof value === 'string', {
+      representation: { id: 'example/opaque', payload: { annotations: 'second', isMutable: true } },
+    })
+
+    expect(fingerprint(makeJsonTable('documents', first).ast)).not.toBe(
+      fingerprint(makeJsonTable('documents', second).ast),
+    )
+  })
+
+  test('tracks JSON codecs passed through the generic text column API', () => {
+    const first = SqliteDsl.table('documents', {
+      value: SqliteDsl.text({ schema: Schema.fromJsonString(Schema.Struct({ value: Schema.String })) }),
+    })
+    const second = SqliteDsl.table('documents', {
+      value: SqliteDsl.text({ schema: Schema.fromJsonString(Schema.Struct({ value: Schema.Finite })) }),
+    })
+
+    expect(fingerprint(first.ast)).not.toBe(fingerprint(second.ast))
+  })
+
+  test('gives equivalent JSON DSL forms the same fingerprint', () => {
+    const valueSchema = Schema.Struct({ value: Schema.String })
+    const specialized = SqliteDsl.table('documents', {
+      value: SqliteDsl.json({ schema: valueSchema }),
+    })
+    const generic = SqliteDsl.table('documents', {
+      value: SqliteDsl.text({ schema: Schema.fromJsonString(valueSchema) }),
+    })
+
+    expect(fingerprint(specialized.ast)).toBe(fingerprint(generic.ast))
+  })
+
+  test('classifies physical defaults without hashing function source text', () => {
+    const none = SqliteDsl.text()
+    const firstThunk = SqliteDsl.text({ default: () => 'first' })
+    const secondThunk = SqliteDsl.text({ default: () => 'second' })
+    const literal = SqliteDsl.text({ default: 'first' })
+    const toTable = (definition: SqliteDsl.ColumnDefinition.Any) =>
+      SqliteDsl.table('defaults', { value: definition }).ast
+
+    expect(fingerprint(toTable(firstThunk))).toBe(fingerprint(toTable(secondThunk)))
+    expect(fingerprint(toTable(firstThunk))).not.toBe(fingerprint(toTable(none)))
+    expect(fingerprint(toTable(literal))).not.toBe(fingerprint(toTable(firstThunk)))
+  })
+})
+
+const makePhysicalTable = () =>
+  SqliteDsl.table(
+    'users',
+    {
+      id: SqliteDsl.text({ primaryKey: true }),
+      age: SqliteDsl.integer({ nullable: true }),
+    },
+    [{ name: 'users_by_age', columns: ['age'], isUnique: false }],
+  )
+
+const makeJsonTable = (name: string, schema: Schema.Codec<unknown, unknown>) =>
+  SqliteDsl.table(name, {
+    id: SqliteDsl.text({ primaryKey: true }),
+    value: SqliteDsl.json({ schema }),
+  })
+
+const representativeJsonSchema = Schema.Struct({
+  title: Schema.String.check(Schema.isMinLength(1)),
+  tags: Schema.Array(Schema.String),
+  status: Schema.Union([Schema.Literal('draft'), Schema.Literal('published')]),
+  publishedAt: Schema.NullOr(Schema.DateFromString),
+  metadata: Schema.Record(Schema.String, Schema.Json),
+})
+
+/** Uses the JSON-compatible checks whose representation ids the fingerprint normalizes. */
+const normalizedCheckIdsJsonSchema = Schema.Struct({
+  slug: Schema.String.check(
+    Schema.isBetweenLength(1, 64),
+    Schema.isStartingWith('a'),
+    Schema.isEndingWith('z'),
+    Schema.isIncluding('-'),
+  ),
+  tags: Schema.Array(Schema.String).check(Schema.isBetweenLength(0, 10)),
+  initial: Schema.Char,
+  labels: Schema.Record(Schema.String, Schema.String).check(Schema.isBetweenProperties(0, 5)),
+})
+
+interface TreeNode {
+  readonly value: string
+  readonly children: ReadonlyArray<TreeNode>
+}
+
+const makeTreeSchema = (): Schema.Codec<TreeNode> => {
+  const TreeNode: Schema.Codec<TreeNode> = Schema.Struct({
+    value: Schema.String,
+    children: Schema.Array(Schema.suspend(() => TreeNode)),
+  })
+  return TreeNode
+}