zeed 1.5.0 → 1.8.0

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "zeed",
   "type": "module",
-  "version": "1.5.0",
-  "packageManager": "pnpm@10.33.0",
+  "version": "1.8.0",
   "description": "🌱 Simple foundation library",
   "author": {
     "name": "Dirk Holtwick",
@@ -56,6 +55,22 @@
   "engines": {
     "node": ">=20"
   },
+  "devDependencies": {
+    "@antfu/eslint-config": "^8.2.0",
+    "@antfu/ni": "^30.0.0",
+    "@types/node": "^25.6.0",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vitest/browser": "^4.1.4",
+    "@vitest/coverage-v8": "^4.1.4",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.2.1",
+    "playwright": "^1.59.1",
+    "pnpm": "^10.32.1",
+    "tsdown": "^0.21.9",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
+  },
   "scripts": {
     "build": "nr clean && NODE_ENV=production tsdown",
     "build:docs": "nlx typedoc --skipErrorChecking ./src/index.all.ts",
@@ -66,33 +81,15 @@
     "clean": "rm -rf dist",
     "coverage": "vitest --run --coverage",
     "lint": "eslint . --fix",
-    "prepublishOnly": "nr build && nr circles",
     "start": "nr watch",
     "test": "nr check && vitest --run",
     "test:browser": "PREVIEW=1 vitest",
     "test:firefox": "BROWSER=firefox vitest",
     "test:webkit": "BROWSER=webkit vitest",
     "test:chromium": "BROWSER=chromium vitest",
-    "test:release": "nr lint && nr check && vitest --run",
-    "post:release": "nr upload:docs && nr npm:release",
-    "npm:release": "npm login && npm publish --access public",
-    "watch": "nr build -- --watch src",
-    "prep": "nr lint && nr check && nr test:release && nr upload:docs"
-  },
-  "devDependencies": {
-    "@antfu/eslint-config": "^8.2.0",
-    "@antfu/ni": "^30.0.0",
-    "@types/node": "^25.6.0",
-    "@vitejs/plugin-vue": "^6.0.6",
-    "@vitest/browser": "^4.1.4",
-    "@vitest/coverage-v8": "^4.1.4",
-    "esbuild": "^0.28.0",
-    "eslint": "^10.2.1",
-    "playwright": "^1.59.1",
-    "pnpm": "^10.32.1",
-    "tsdown": "^0.21.9",
-    "typescript": "^6.0.3",
-    "vite": "^8.0.8",
-    "vitest": "^4.1.4"
+    "pre:release": "nr lint && nr check",
+    "test:release": "vitest --run",
+    "post:release": "nr upload:docs && pnpm publish",
+    "watch": "nr build -- --watch src"
   }
-}
+}

package/src/common/bin/lib0/decoding.spec.ts

@@ -1,4 +1,5 @@
-import { createDecoder, peekUint8, peekUint16, peekUint32, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readUint8, readUint16, readUint32, readUint32BigEndian, readVarInt, readVarString, readVarUint, readVarUint8Array } from './decoding'
+import { afterEach, vi } from 'vitest'
+import { clone, createDecoder, hasContent, peekUint8, peekUint16, peekUint32, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readTailAsUint8Array, readUint8, readUint16, readUint32, readUint32BigEndian, readVarInt, readVarString, readVarUint, readVarUint8Array, skip8 } from './decoding'
 import { createBinEncoder, writeAny, writeBigInt64, writeBigUint64, writeFloat32, writeFloat64, writeUint8, writeUint16, writeUint32, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
 
 describe('lib0/decoding', () => {
@@ -79,6 +80,88 @@ describe('lib0/decoding', () => {
     expect(readAny(d)).toEqual({ a: 1, b: 2 })
   })
 
+  it('hasContent reflects position', () => {
+    const d = createDecoder(new Uint8Array([1, 2]))
+    expect(hasContent(d)).toBe(true)
+    readUint8(d)
+    readUint8(d)
+    expect(hasContent(d)).toBe(false)
+  })
+
+  it('clone preserves and overrides position', () => {
+    const d = createDecoder(new Uint8Array([1, 2, 3]))
+    readUint8(d)
+    const c1 = clone(d)
+    expect(c1.pos).toBe(1)
+    expect(c1.arr).toBe(d.arr)
+    const c2 = clone(d, 0)
+    expect(c2.pos).toBe(0)
+  })
+
+  it('skip8 advances one byte', () => {
+    const d = createDecoder(new Uint8Array([7, 8]))
+    skip8(d)
+    expect(d.pos).toBe(1)
+    expect(readUint8(d)).toBe(8)
+  })
+
+  it('readTailAsUint8Array returns remaining bytes', () => {
+    const d = createDecoder(new Uint8Array([1, 2, 3, 4]))
+    readUint8(d)
+    const tail = readTailAsUint8Array(d)
+    expect([...tail]).toEqual([2, 3, 4])
+  })
+
+  it('readVarUint throws on unexpected end of array', () => {
+    const d = createDecoder(new Uint8Array([0x80, 0x80]))
+    expect(() => readVarUint(d)).toThrow(/Unexpected end of array/)
+  })
+
+  it('readVarInt throws on unexpected end of array', () => {
+    const d = createDecoder(new Uint8Array([0x80]))
+    expect(() => readVarInt(d)).toThrow(/Unexpected end of array/)
+  })
+
+  it('readVarUint throws on integer out of range', () => {
+    const bytes = new Uint8Array(12).fill(0xFF)
+    bytes[11] = 0x7F
+    const d = createDecoder(bytes)
+    expect(() => readVarUint(d)).toThrow(/Integer out of Range/)
+  })
+
+  it('readVarInt throws on integer out of range', () => {
+    const bytes = new Uint8Array(12).fill(0xFF)
+    bytes[11] = 0x7F
+    const d = createDecoder(bytes)
+    expect(() => readVarInt(d)).toThrow(/Integer out of Range/)
+  })
+
+  describe('polyfill path', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('readVarString via polyfill (empty, small, large)', async () => {
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const dec = await import('./decoding')
+      const enc = await import('./encoding')
+
+      const e = enc.createBinEncoder()
+      enc.writeVarString(e, '')
+      enc.writeVarString(e, 'abc')
+      const big = 'y'.repeat(15000)
+      enc.writeVarString(e, big)
+      const arr = enc.encodeToUint8Array(e)
+
+      const d = dec.createDecoder(arr)
+      expect(dec.readVarString(d)).toBe('')
+      expect(dec.readVarString(d)).toBe('abc')
+      expect(dec.readVarString(d)).toBe(big)
+    })
+  })
+
   it('should peek values', () => {
     const e = createBinEncoder()
     writeUint8(e, 42)

package/src/common/bin/lib0/encoding.spec.ts

@@ -1,4 +1,6 @@
-import { createBinEncoder, encodeToUint8Array, isNegativeZero, setUint8, setUint16, setUint32, writeAny, writeBigInt64, writeBigUint64, writeFloat32, writeFloat64, writeUint8, writeUint8Array, writeUint16, writeUint32, writeUint32BigEndian, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
+import { afterEach, vi } from 'vitest'
+import { createDecoder, readAny, readVarInt as readVarIntDec, readVarString } from './decoding'
+import { createBinEncoder, encodeToUint8Array, isNegativeZero, length, setUint8, setUint16, setUint32, verifyLen, writeAny, writeBigInt64, writeBigUint64, writeBinaryEncoder, writeFloat32, writeFloat64, writeUint8, writeUint8Array, writeUint16, writeUint32, writeUint32BigEndian, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
 
 describe('lib0/encoding', () => {
   it('should encode/decode uint8/16/32', () => {
@@ -84,4 +86,110 @@ describe('lib0/encoding', () => {
     expect(isNegativeZero(1)).toBe(false)
     expect(isNegativeZero(-1)).toBe(true)
   })
+
+  it('grows buffers when exceeding initial capacity', () => {
+    const e = createBinEncoder()
+    for (let i = 0; i < 250; i++) writeUint8(e, i & 0xFF)
+    expect(length(e)).toBe(250)
+    expect(e.bufs.length).toBeGreaterThan(0)
+    const arr = encodeToUint8Array(e)
+    expect(arr.length).toBe(250)
+    expect(arr[0]).toBe(0)
+    expect(arr[249]).toBe(249 & 0xFF)
+  })
+
+  it('verifyLen allocates a fresh buffer when required', () => {
+    const e = createBinEncoder()
+    writeUint8(e, 1)
+    verifyLen(e, 200)
+    expect(e.bufs.length).toBe(1)
+    writeUint8(e, 2)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(1)
+    expect(arr[1]).toBe(2)
+  })
+
+  it('set updates bytes across multiple buffers', () => {
+    const e = createBinEncoder()
+    for (let i = 0; i < 250; i++) writeUint8(e, 0)
+    setUint8(e, 0, 0xAA)
+    setUint8(e, 120, 0xBB)
+    setUint8(e, 240, 0xCC)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(0xAA)
+    expect(arr[120]).toBe(0xBB)
+    expect(arr[240]).toBe(0xCC)
+  })
+
+  it('writeUint8Array splits across buffers', () => {
+    const e = createBinEncoder()
+    writeUint8(e, 9)
+    const data = new Uint8Array(300)
+    for (let i = 0; i < data.length; i++) data[i] = i & 0xFF
+    writeUint8Array(e, data)
+    const arr = encodeToUint8Array(e)
+    expect(arr.length).toBe(301)
+    expect(arr[0]).toBe(9)
+    expect(arr[1]).toBe(0)
+    expect(arr[300]).toBe(299 & 0xFF)
+  })
+
+  it('writeBinaryEncoder appends another encoder', () => {
+    const inner = createBinEncoder()
+    writeUint8(inner, 1)
+    writeUint8(inner, 2)
+    const outer = createBinEncoder()
+    writeUint8(outer, 0)
+    writeBinaryEncoder(outer, inner)
+    const arr = encodeToUint8Array(outer)
+    expect([...arr]).toEqual([0, 1, 2])
+  })
+
+  it('writes long strings via alternate path', () => {
+    const e = createBinEncoder()
+    const big = 'z'.repeat(15000)
+    writeVarString(e, big)
+    const arr = encodeToUint8Array(e)
+    const d = createDecoder(arr)
+    expect(readVarString(d)).toBe(big)
+  })
+
+  it('writeVarInt handles multi-byte large values', () => {
+    const e = createBinEncoder()
+    writeVarInt(e, 1_000_000)
+    writeVarInt(e, -1_000_000)
+    const arr = encodeToUint8Array(e)
+    const d = createDecoder(arr)
+    expect(readVarIntDec(d)).toBe(1_000_000)
+    expect(readVarIntDec(d)).toBe(-1_000_000)
+  })
+
+  it('writeAny encodes float32-representable numbers compactly', () => {
+    const e = createBinEncoder()
+    writeAny(e, 0.5)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(124)
+    const d = createDecoder(arr)
+    expect(readAny(d)).toBe(0.5)
+  })
+
+  describe('polyfill path', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('writeVarString via polyfill when TextEncoder missing', async () => {
+      vi.stubGlobal('TextEncoder', undefined)
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const enc = await import('./encoding')
+      const dec = await import('./decoding')
+      const e = enc.createBinEncoder()
+      enc.writeVarString(e, 'hi✓')
+      const arr = enc.encodeToUint8Array(e)
+      const d = dec.createDecoder(arr)
+      expect(dec.readVarString(d)).toBe('hi✓')
+    })
+  })
 })

package/src/common/bin/lib0/string.spec.ts

@@ -1,4 +1,5 @@
-import { decodeUtf8, encodeUtf8, fromCamelCase, splice, trimLeft, utf8ByteLength } from './string'
+import { afterEach, vi } from 'vitest'
+import { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, splice, trimLeft, utf8ByteLength } from './string'
 
 describe('lib0/string', () => {
   it('should trim left', () => {
@@ -31,4 +32,47 @@ describe('lib0/string', () => {
     expect(splice('abcdef', 0, 3, 'Z')).toBe('Zdef')
     expect(splice('abcdef', 3, 0, 'Q')).toBe('abcQdef')
   })
+
+  it('should encode utf8 via polyfill', () => {
+    const bytes = _encodeUtf8Polyfill('hi✓')
+    expect(bytes).toBeInstanceOf(Uint8Array)
+    expect(decodeUtf8(bytes)).toBe('hi✓')
+  })
+
+  describe('polyfill paths via module reset', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('uses polyfill when TextEncoder/TextDecoder unavailable', async () => {
+      vi.stubGlobal('TextEncoder', undefined)
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const mod = await import('./string')
+      const encoded = mod.encodeUtf8('hello✓')
+      expect(encoded).toBeInstanceOf(Uint8Array)
+      expect(mod.decodeUtf8(encoded)).toBe('hello✓')
+      expect(mod.getUtf8TextEncoder()).toBeNull()
+    })
+
+    it('decodes via polyfill for a large buffer', async () => {
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const mod = await import('./string')
+      const big = 'a'.repeat(15000)
+      const bytes = new TextEncoder().encode(big)
+      expect(mod.decodeUtf8(bytes)).toBe(big)
+    })
+
+    it('disables broken TextDecoder (Safari BOM workaround)', async () => {
+      class FakeDecoder {
+        decode() { return 'x' }
+      }
+      vi.stubGlobal('TextDecoder', FakeDecoder as any)
+      vi.resetModules()
+      const mod = await import('./string')
+      expect(mod.getUtf8TextDecoder()).toBeNull()
+    })
+  })
 })

package/src/common/crypto/crypto.spec.ts

@@ -84,6 +84,13 @@ describe('crypto', () => {
     expect(typeof key).toBe('object')
   })
 
+  it('should derive keys without salt (default branch)', async () => {
+    const key = await deriveKeyPbkdf2(new Uint8Array([1, 2, 3]))
+    expect(key).toBeDefined()
+    const keyCbc = await (await import('./crypto')).deriveKeyPbkdf2CBC(new Uint8Array([1, 2, 3]))
+    expect(keyCbc).toBeDefined()
+  })
+
   it('should handle zero-length random and digest', async () => {
     expect(randomUint8Array(0)).toEqual(new Uint8Array(0))
     expect((await digest(new Uint8Array(0))).length).toBeGreaterThan(0)

package/src/common/crypto/xaes.spec.ts

@@ -80,6 +80,54 @@ describe('xaes.spec', () => {
     expect(new Uint8Array(decrypted)).toEqual(plaintext)
   })
 
+  it('xaes rejects wrong algorithm key', async () => {
+    const key = await crypto.subtle.generateKey(
+      { name: 'AES-GCM', length: 256 },
+      false,
+      ['encrypt', 'decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/AES-CBC/)
+  })
+
+  it('xaes rejects key without encrypt usage', async () => {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      new Uint8Array(32).fill(0x05),
+      { name: 'AES-CBC', length: 256 },
+      false,
+      ['decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/encrypt/)
+  })
+
+  it('xaes rejects key of wrong length', async () => {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      new Uint8Array(16).fill(0x06),
+      { name: 'AES-CBC', length: 128 },
+      false,
+      ['encrypt', 'decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/256 bits/)
+  })
+
+  it('xaes rejects iv of wrong length', async () => {
+    const key = await generateKeyXAES()
+    await expect(encryptXAES({ iv: new Uint8Array(12) }, key, new Uint8Array(1))).rejects.toThrow(/24 bytes/)
+  })
+
+  it('xaes accepts iv as ArrayBuffer', async () => {
+    const key = await generateKeyXAES()
+    const ivBuffer = new Uint8Array(24).fill(7).buffer
+    const data = new Uint8Array(10).fill(2)
+    const encrypted = await encryptXAES({ iv: ivBuffer }, key, data)
+    const decrypted = await decryptXAES({ iv: ivBuffer }, key, encrypted)
+    expect(new Uint8Array(decrypted)).toEqual(data)
+  })
+
   // it('xaes test vector, accumulated', async () => {
   //   const hash = new SHAKE128()
   //   const rng = new SHAKE128()

package/src/common/data/deep.spec.ts

@@ -174,6 +174,51 @@ describe('deep', () => {
   //   // expect(a.one.sample.a === b.one.sample.a).toBe(true)
   // })
 
+  it('deepEqual handles branch cases', () => {
+    expect(deepEqual(1, 2)).toBe(false)
+    expect(deepEqual(null, {})).toBe(false)
+    expect(deepEqual({}, null)).toBe(false)
+    class A { x = 1 }
+    class B { x = 1 }
+    expect(deepEqual(new A(), new B())).toBe(false)
+    expect(deepEqual({ a: 1 }, { b: 1 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+    expect(deepEqual({ a: 1, b: 2 }, { a: 1, c: 2 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { a: 1 })).toBe(true)
+
+    const proto = { inherited: 1 }
+    const x: any = Object.create(proto)
+    x.own = 1
+    const y: any = Object.create(proto)
+    y.own = 1
+    expect(deepEqual(x, y)).toBe(true)
+  })
+
+  it('deepStripUndefinedInPlace handles cycles and primitives', () => {
+    expect(deepStripUndefinedInPlace(5)).toBe(5)
+    const cyc: any = { a: 1 }
+    cyc.self = cyc
+    const result = deepStripUndefinedInPlace(cyc)
+    expect(result).toBe(cyc)
+    expect(cyc.a).toBe(1)
+    const obj: any = Object.create({ inherited: 1 })
+    obj.own = undefined
+    obj.keep = 2
+    deepStripUndefinedInPlace(obj)
+    expect('own' in obj).toBe(false)
+    expect(obj.keep).toBe(2)
+  })
+
+  it('deepMerge handles non-object target and source', () => {
+    expect(deepMerge(null as any, { a: 1 })).toEqual({ a: 1 })
+    expect(deepMerge({ a: 1 }, null)).toEqual({ a: 1 })
+    expect(deepMerge({ a: 1 }, 'str' as any)).toEqual({ a: 1 })
+  })
+
+  it('deepMerge concatenates arrays', () => {
+    expect(deepMerge({ list: [1, 2] }, { list: [3, 4] })).toEqual({ list: [1, 2, 3, 4] })
+  })
+
   it('should strip undefined', () => {
     const sample = {
       hello: {

package/src/common/data/regexp.spec.ts

@@ -0,0 +1,30 @@
+import { escapeRegExp } from './regexp'
+
+describe('escapeRegExp', () => {
+  it('returns empty string for falsy input', () => {
+    expect(escapeRegExp('')).toBe('')
+    // @ts-expect-error testing falsy
+    expect(escapeRegExp(undefined)).toBe('')
+    // @ts-expect-error testing falsy
+    expect(escapeRegExp(null)).toBe('')
+  })
+
+  it('returns source of RegExp input', () => {
+    expect(escapeRegExp(/foo\.bar/)).toBe('foo\\.bar')
+  })
+
+  it('escapes all special characters', () => {
+    expect(escapeRegExp('\\-[]/{}()*+?.^$|')).toBe('\\\\\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\^\\$\\|')
+  })
+
+  it('leaves normal characters alone', () => {
+    expect(escapeRegExp('hello world 123')).toBe('hello world 123')
+  })
+
+  it('escaped string works as literal in RegExp', () => {
+    const src = 'a.b+c'
+    const re = new RegExp(escapeRegExp(src))
+    expect(re.test('a.b+c')).toBe(true)
+    expect(re.test('axbxc')).toBe(false)
+  })
+})

package/src/common/schema/index.ts

@@ -7,7 +7,6 @@ export * from './parse-object'
 export * from './schema'
 export * from './schema-standard'
 export * from './serialize'
-export * from './sql'
 export * from './type-test'
 export * from './utils'
 export * from './z'

package/src/common/schema/_sandbox/sandbox-inherit.ts

@@ -1,13 +0,0 @@
-// class TypeClass<T = unknown> {
-//   optional(): TypeClass<T | undefined> {
-//     return this
-//   }
-// }
-
-// class TypeStringClass<T extends string> extends TypeClass<T> {
-
-// }
-
-// const o = new TypeStringClass()
-// const v = o.optional()
-// type t = typeof v // expect: TypeStringClass<string | undefined>

package/src/common/schema/_sandbox/sandbox.ts

@@ -1,42 +0,0 @@
-// // Function
-
-// interface Type<T = unknown> {
-//   _value?: T
-// }
-
-// type Infer<T> = T extends Type<infer TT> ? TT : never
-
-// type TupleOutput<T extends Type[]> = {
-//   [K in keyof T]: T[K] extends Type<infer U> ? U : never;
-// }
-
-// type ArrayOutput<Head extends Type[], Rest extends Type | undefined> = [
-//   ...TupleOutput<Head>,
-//   ...(Rest extends Type ? Infer<Rest>[] : []),
-// ]
-
-// type ArrayType<
-//   Head extends Type[] = Type[],
-//   Rest extends Type | undefined = Type | undefined,
-// > = Type<ArrayOutput<Head, Rest>>
-
-// function tuple<T extends [] | [Type, ...Type[]]>(items: T): ArrayType<T, undefined> {
-//   return {} as any
-// }
-
-// function string(): Type<string> {
-//   return {} as any
-// }
-
-// function boolean(): Type<boolean> {
-//   return {} as any
-// }
-
-// function number(): Type<number> {
-//   return {} as any
-// }
-
-// const tt = tuple([number(), string(), boolean()])
-// type ttt = Infer<typeof tt> // expected [number, string, boolean]
-
-// //

package/src/common/schema/_sandbox/sandbox.xspec.ts

@@ -1,45 +0,0 @@
-// /* eslint-disable ts/no-unsafe-declaration-merging */
-// // // Define an interface for the instance type
-// // interface MyTypeInstance {
-// //   value: number
-// //   test: () => number
-// // }
-
-// // // Constructor function
-// // function MyType(this: MyTypeInstance, value: number) {
-// //   this.value = value
-// // }
-
-// // MyType.prototype.test = function () {
-// //   return this.value
-// // }
-
-// class MyType {
-//   value: number
-//   constructor(value: number) {
-//     this.value = value
-//   }
-// }
-
-// interface MyType {
-//   test: () => number
-// }
-
-// describe('sandbox.spec', () => {
-//   it('should do something', async () => {
-//     // Create an instance of MyType using the 'new' keyword
-//     const my = new MyType(123)
-
-//     MyType.prototype.test = function () {
-//       return this.value + 1
-//     }
-
-//     // Example usage
-//     expect(my.test()).toMatchInlineSnapshot(`124`)
-//     expect(my).toMatchInlineSnapshot(`
-//       MyType {
-//         "value": 123,
-//       }
-//     `)
-//   })
-// })

package/src/common/schema/sql/README.md

@@ -1,254 +0,0 @@
-# SQL Select Builder
-
-A minimal, type-safe SQL `SELECT` builder built on top of zeed's `z` schema system. Inspired by Drizzle ORM and Kysely, but deliberately small: single-table queries, no joins, no inserts/updates/deletes.
-
-The goal is to get full TypeScript inference, editor autocompletion, and - uniquely - per-query dependency tracking for reactive use cases.
-
-## Features
-
-- Type-safe table definitions backed by `z` schemas
-- Full row type inference for results, including narrowed `pick`/`select` forms
-- Editor autocompletion on column keys
-- Parameterized SQL output (`?` placeholders, values returned separately)
-- Per-query dependency tracking split by role: `select`, `where`, `orderBy`
-- Zero runtime dependencies, tree-shakable
-
-## Quick Start
-
-```ts
-import { and, boolean, eq, from, gt, inArray, int, like, or, string, table } from 'zeed'
-
-const users = table('users', {
-  id: int(),
-  name: string(),
-  email: string(),
-  age: int(),
-  active: boolean(),
-})
-
-const query = from(users)
-  .pick('id', 'name')
-  .where(and(eq(users.active, true), gt(users.age, 18)))
-  .orderBy(users.name)
-  .limit(20)
-
-const { sql, params } = query.toSQL()
-// sql:    SELECT "users"."id", "users"."name" FROM "users"
-//         WHERE ("users"."active" = ?) AND ("users"."age" > ?)
-//         ORDER BY "users"."name" ASC LIMIT ?
-// params: [true, 18, 20]
-```
-
-## Defining Tables
-
-A table pairs a name with a `z`-schema shape. Each column becomes a typed reference usable in expressions.
-
-```ts
-const posts = table('posts', {
-  id: int(),
-  title: string(),
-  body: string(),
-  authorId: int(),
-  published: boolean(),
-})
-
-posts.id // Column<number>
-posts.title // Column<string>
-```
-
-The shape is a plain `Record<string, Type>`, so any `z` type works (`string`, `int`, `boolean`, `stringLiterals`, ...).
-
-## Selecting Columns
-
-Three forms, depending on how much control you need.
-
-### 1. Full row (default)
-
-```ts
-from(users)
-// Row: { id: number, name: string, email: string, age: number, active: boolean }
-```
-
-### 2. `pick(...keys)` - compact and typed
-
-```ts
-from(users).pick('id', 'email')
-// Row: { id: number, email: string }
-```
-
-Keys are typed against the table shape, so the editor autocompletes valid column names and rejects unknown ones at compile time.
-
-### 3. `select({ alias: column })` - for aliases or mixed expressions
-
-```ts
-import { select } from 'zeed'
-
-select({ uid: users.id, n: users.name }).from(users)
-// Row: { uid: number, n: string }
-// SQL: SELECT "users"."id" AS "uid", "users"."name" AS "n" FROM "users"
-```
-
-## Where Clauses
-
-Expressions are built from operator helpers. Columns and literal values can be mixed freely - literals are automatically bound as parameters.
-
-```ts
-import { and, eq, gt, gte, inArray, like, lt, ne, or, sqlIsNotNull, sqlIsNull } from 'zeed'
-
-from(users).where(
-  and(
-    eq(users.active, true),
-    or(
-      like(users.name, 'A%'),
-      inArray(users.id, [1, 2, 3]),
-    ),
-    sqlIsNotNull(users.email),
-  ),
-)
-```
-
-Available operators:
-
-| Helper          | SQL          |
-| --------------- | ------------ |
-| `eq(a, b)`      | `a = b`      |
-| `ne(a, b)`      | `a <> b`     |
-| `gt(a, b)`      | `a > b`      |
-| `gte(a, b)`     | `a >= b`     |
-| `lt(a, b)`      | `a < b`      |
-| `lte(a, b)`     | `a <= b`     |
-| `like(a, b)`    | `a LIKE b`   |
-| `inArray(a, [])`| `a IN (...)` |
-| `sqlIsNull(a)`  | `a IS NULL`  |
-| `sqlIsNotNull(a)` | `a IS NOT NULL` |
-| `and(...)`      | `(..) AND (..)` |
-| `or(...)`       | `(..) OR (..)`  |
-| `not(e)`        | `NOT (..)`   |
-
-`and` and `or` accept `undefined`, `false`, and `null` entries and drop them, which is handy for conditional filters.
-
-Note: `sqlIsNull` and `sqlIsNotNull` are prefixed to avoid collision with zeed's existing `isNull`/`isNotNull` data helpers.
-
-## Ordering, Limit, Offset
-
-```ts
-from(users)
-  .orderBy(users.age, 'DESC')
-  .orderBy(users.name) // ASC by default
-  .limit(10)
-  .offset(20)
-```
-
-## Compiling a Query
-
-```ts
-const { sql, params, dependencies } = query.toSQL()
-```
-
-- `sql` - the query string with `?` placeholders
-- `params` - array of bound values in order
-- `dependencies` - see below
-
-Pass `sql` and `params` to whichever SQLite/Postgres/MySQL driver you use.
-
-## Dependency Tracking
-
-Every compiled query reports exactly which table columns it touches, split by role. This is the key building block for reactive queries: when the database changes, you can decide whether a given query needs to re-run based on which columns were affected.
-
-```ts
-const q = from(users)
-  .pick('id', 'name')
-  .where(eq(users.email, 'a@b.c'))
-  .orderBy(users.age, 'DESC')
-
-q.toSQL().dependencies
-// [
-//   {
-//     table: 'users',
-//     select:  ['id', 'name'],  // fields returned to the caller
-//     where:   ['email'],       // fields used in filters
-//     orderBy: ['age'],         // fields used for ordering
-//     all:     ['age', 'email', 'id', 'name'], // union of the above
-//   }
-// ]
-```
-
-### Example: reactive invalidation
-
-```ts
-function isAffected(
-  deps: readonly QueryDependencies[],
-  change: { table: string, columns: string[] },
-): boolean {
-  return deps.some(d =>
-    d.table === change.table
-    && d.all.some(c => change.columns.includes(c)),
-  )
-}
-
-// On a write notification from the database:
-if (isAffected(query.toSQL().dependencies, { table: 'users', columns: ['email'] })) {
-  // re-run the query, push new rows to subscribers
-}
-```
-
-Splitting by role lets you optimize further:
-
-- A change to a `select` column means the result *shape* changes - re-render.
-- A change to a `where` or `orderBy` column means the result *set* may change - re-query.
-- A change to a column not in `all` is irrelevant - skip.
-
-## Type Inference
-
-Row types flow through the builder. Use `InferRow` to extract the result type for downstream code:
-
-```ts
-import type { InferRow } from 'zeed'
-
-const query = from(users).pick('id', 'email')
-type Row = InferRow<typeof query> // { id: number, email: string }
-
-function render(rows: Row[]) { /* ... */ }
-render(await run(query))
-```
-
-## Scope and Limitations
-
-By design, this builder is minimal:
-
-- `SELECT` only. No `INSERT`, `UPDATE`, `DELETE`, `CREATE TABLE`.
-- Single table per query. No `JOIN`, no subqueries, no CTEs.
-- No aggregate functions (`COUNT`, `SUM`, `GROUP BY`, `HAVING`).
-- One SQL dialect (`?` placeholders, double-quoted identifiers). Works with SQLite and, with most drivers, Postgres.
-
-The existing `select({...}).from(...)` form remains available for cases that need column aliases. If you need joins or mutations, use a dedicated ORM - this module is intended for read-only queries in reactive contexts where dependency tracking is the main value-add.
-
-## API Reference
-
-### `table(name, shape)`
-
-Creates a table handle. `shape` is a `Record<string, Type>` from `z`. Returns an object where each key is a typed `Column` plus `_name` and `_shape` metadata.
-
-### `from(table)`
-
-Starts a query. Returns a `SelectBuilder` with the full row type as its default result.
-
-### `select(selection?)`
-
-Alternative entry point. With no argument, behaves like a full-row select (requires a subsequent `.from(...)`). With a `{ alias: column }` map, creates an aliased selection.
-
-### `SelectBuilder`
-
-Chainable methods:
-
-- `.from(table)` - set the source table (only needed after `select()`)
-- `.pick(...keys)` - narrow to specific columns by name
-- `.where(expr)` - set the WHERE clause
-- `.orderBy(column, 'ASC' | 'DESC')` - append an ORDER BY entry
-- `.limit(n)` / `.offset(n)`
-- `.toSQL()` - compile to `{ sql, params, dependencies }`
-- `.dependencies()` - shortcut that returns just the dependencies
-
-### `InferRow<Query>`
-
-Type helper that extracts the row type from a builder or compiled query.

package/src/common/schema/sql/expr.ts

@@ -1,99 +0,0 @@
-import type { Column } from './table'
-import { isColumn } from './table'
-
-export interface Expr {
-  readonly kind: 'expr'
-  readonly sql: string
-  readonly params: unknown[]
-  readonly refs: Column[]
-}
-
-function operand(v: any): Expr {
-  if (isColumn(v)) {
-    return {
-      kind: 'expr',
-      sql: `"${v._table}"."${v._name}"`,
-      params: [],
-      refs: [v],
-    }
-  }
-  if (v && v.kind === 'expr')
-    return v as Expr
-  return { kind: 'expr', sql: '?', params: [v], refs: [] }
-}
-
-function binop(op: string) {
-  return (a: Column | Expr | unknown, b: Column | Expr | unknown): Expr => {
-    const x = operand(a)
-    const y = operand(b)
-    return {
-      kind: 'expr',
-      sql: `${x.sql} ${op} ${y.sql}`,
-      params: [...x.params, ...y.params],
-      refs: [...x.refs, ...y.refs],
-    }
-  }
-}
-
-export const eq = binop('=')
-export const ne = binop('<>')
-export const gt = binop('>')
-export const gte = binop('>=')
-export const lt = binop('<')
-export const lte = binop('<=')
-export const like = binop('LIKE')
-
-export function and(...parts: (Expr | undefined | false | null)[]): Expr {
-  const list = parts.filter((p): p is Expr => !!p)
-  if (list.length === 0)
-    return { kind: 'expr', sql: '1=1', params: [], refs: [] }
-  if (list.length === 1)
-    return list[0]
-  return {
-    kind: 'expr',
-    sql: list.map(p => `(${p.sql})`).join(' AND '),
-    params: list.flatMap(p => p.params),
-    refs: list.flatMap(p => p.refs),
-  }
-}
-
-export function or(...parts: (Expr | undefined | false | null)[]): Expr {
-  const list = parts.filter((p): p is Expr => !!p)
-  if (list.length === 0)
-    return { kind: 'expr', sql: '1=0', params: [], refs: [] }
-  if (list.length === 1)
-    return list[0]
-  return {
-    kind: 'expr',
-    sql: list.map(p => `(${p.sql})`).join(' OR '),
-    params: list.flatMap(p => p.params),
-    refs: list.flatMap(p => p.refs),
-  }
-}
-
-export function not(e: Expr): Expr {
-  return { kind: 'expr', sql: `NOT (${e.sql})`, params: e.params, refs: e.refs }
-}
-
-export function sqlIsNull(col: Column | Expr): Expr {
-  const x = operand(col)
-  return { kind: 'expr', sql: `${x.sql} IS NULL`, params: x.params, refs: x.refs }
-}
-
-export function sqlIsNotNull(col: Column | Expr): Expr {
-  const x = operand(col)
-  return { kind: 'expr', sql: `${x.sql} IS NOT NULL`, params: x.params, refs: x.refs }
-}
-
-export function inArray(col: Column | Expr, values: unknown[]): Expr {
-  const x = operand(col)
-  if (values.length === 0)
-    return { kind: 'expr', sql: '1=0', params: [], refs: x.refs }
-  const placeholders = values.map(() => '?').join(', ')
-  return {
-    kind: 'expr',
-    sql: `${x.sql} IN (${placeholders})`,
-    params: [...x.params, ...values],
-    refs: x.refs,
-  }
-}

package/src/common/schema/sql/index.ts

@@ -1,3 +0,0 @@
-export * from './expr'
-export * from './select'
-export * from './table'

package/src/common/schema/sql/select.spec.ts

@@ -1,144 +0,0 @@
-import type { Expect, IsEqual } from '../type-test'
-import type { InferRow } from './select'
-import { boolean, int, string } from '../schema'
-import { and, eq, gt, inArray, like, or } from './expr'
-import { from, select } from './select'
-import { table } from './table'
-
-const users = table('users', {
-  id: int(),
-  name: string(),
-  email: string(),
-  age: int(),
-  active: boolean(),
-})
-
-describe('sql select', () => {
-  it('selects all columns of a table', () => {
-    const q = select().from(users).toSQL()
-    expect(q.sql).toBe(
-      'SELECT "users"."id", "users"."name", "users"."email", "users"."age", "users"."active" FROM "users"',
-    )
-    expect(q.params).toEqual([])
-    expect(q.dependencies).toEqual([
-      {
-        table: 'users',
-        select: ['active', 'age', 'email', 'id', 'name'],
-        where: [],
-        orderBy: [],
-        all: ['active', 'age', 'email', 'id', 'name'],
-      },
-    ])
-  })
-
-  it('selects specific columns with type inference', () => {
-    const q = select({ id: users.id, name: users.name }).from(users)
-    type Row = InferRow<typeof q>
-    type _T = Expect<IsEqual<Row, { id: number, name: string }>>
-
-    const c = q.toSQL()
-    expect(c.sql).toBe('SELECT "users"."id", "users"."name" FROM "users"')
-    expect(c.dependencies).toEqual([
-      {
-        table: 'users',
-        select: ['id', 'name'],
-        where: [],
-        orderBy: [],
-        all: ['id', 'name'],
-      },
-    ])
-  })
-
-  it('from() + pick() is a compact form with typed keys', () => {
-    const q = from(users).pick('id', 'name').where(eq(users.email, 'x'))
-    type Row = InferRow<typeof q>
-    type _T = Expect<IsEqual<Row, { id: number, name: string }>>
-
-    const c = q.toSQL()
-    expect(c.sql).toBe(
-      'SELECT "users"."id", "users"."name" FROM "users" WHERE "users"."email" = ?',
-    )
-    expect(c.params).toEqual(['x'])
-    expect(c.dependencies[0].select).toEqual(['id', 'name'])
-    expect(c.dependencies[0].where).toEqual(['email'])
-  })
-
-  it('from() without pick returns the full row', () => {
-    const q = from(users)
-    type Row = InferRow<typeof q>
-    type _T = Expect<IsEqual<Row, {
-      id: number
-      name: string
-      email: string
-      age: number
-      active: boolean
-    }>>
-    expect(q.toSQL().sql).toBe(
-      'SELECT "users"."id", "users"."name", "users"."email", "users"."age", "users"."active" FROM "users"',
-    )
-  })
-
-  it('supports aliases in selection', () => {
-    const q = select({ uid: users.id }).from(users).toSQL()
-    expect(q.sql).toBe('SELECT "users"."id" AS "uid" FROM "users"')
-  })
-
-  it('builds where with parameters', () => {
-    const q = select()
-      .from(users)
-      .where(and(eq(users.active, true), gt(users.age, 18)))
-      .toSQL()
-    expect(q.sql).toContain('WHERE ("users"."active" = ?) AND ("users"."age" > ?)')
-    expect(q.params).toEqual([true, 18])
-  })
-
-  it('separates select, where and orderBy dependencies', () => {
-    const q = select({ id: users.id })
-      .from(users)
-      .where(eq(users.email, 'a@b.c'))
-      .orderBy(users.age, 'DESC')
-      .toSQL()
-    const dep = q.dependencies[0]
-    expect(dep.table).toBe('users')
-    expect(dep.select).toEqual(['id'])
-    expect(dep.where).toEqual(['email'])
-    expect(dep.orderBy).toEqual(['age'])
-    expect(dep.all).toEqual(['age', 'email', 'id'])
-  })
-
-  it('supports or, like, inArray', () => {
-    const q = select()
-      .from(users)
-      .where(or(like(users.name, 'A%'), inArray(users.id, [1, 2, 3])))
-      .toSQL()
-    expect(q.sql).toContain('WHERE ("users"."name" LIKE ?) OR ("users"."id" IN (?, ?, ?))')
-    expect(q.params).toEqual(['A%', 1, 2, 3])
-  })
-
-  it('handles orderBy, limit, offset and tracks orderBy deps', () => {
-    const q = select({ id: users.id })
-      .from(users)
-      .orderBy(users.age, 'DESC')
-      .limit(10)
-      .offset(20)
-      .toSQL()
-    expect(q.sql).toBe(
-      'SELECT "users"."id" FROM "users" ORDER BY "users"."age" DESC LIMIT ? OFFSET ?',
-    )
-    expect(q.params).toEqual([10, 20])
-    expect(q.dependencies[0].select).toEqual(['id'])
-    expect(q.dependencies[0].orderBy).toEqual(['age'])
-    expect(q.dependencies[0].all).toEqual(['age', 'id'])
-  })
-
-  it('dependencies() invalidation check helper', () => {
-    const q = select({ id: users.id }).from(users).where(eq(users.email, 'x'))
-    const deps = q.dependencies()
-    const changedTable = 'users'
-    const changedColumns = ['email']
-    const affected = deps.some(d =>
-      d.table === changedTable && d.all.some(c => changedColumns.includes(c)),
-    )
-    expect(affected).toBe(true)
-  })
-})

package/src/common/schema/sql/select.ts

@@ -1,207 +0,0 @@
-import type { Infer, Type } from '../schema'
-import type { Expr } from './expr'
-import type { Column, TableColumns, TableShape } from './table'
-
-export type RowFromTable<T> = T extends TableColumns<any, infer S>
-  ? { [K in keyof S]: Infer<S[K]> }
-  : never
-
-export type RowFromSelection<S> = {
-  [K in keyof S]: S[K] extends Column<infer T> ? T : never
-}
-
-export interface QueryDependencies {
-  readonly table: string
-  readonly select: readonly string[]
-  readonly where: readonly string[]
-  readonly orderBy: readonly string[]
-  readonly all: readonly string[]
-}
-
-export interface CompiledQuery<Row> {
-  readonly sql: string
-  readonly params: readonly unknown[]
-  readonly dependencies: readonly QueryDependencies[]
-  readonly __row?: Row
-}
-
-interface OrderByEntry {
-  col: Column
-  dir: 'ASC' | 'DESC'
-}
-
-interface SelectState {
-  selection?: Record<string, Column>
-  from?: TableColumns<any, any>
-  where?: Expr
-  orderBy: OrderByEntry[]
-  limit?: number
-  offset?: number
-}
-
-type ShapeRow<S> = { [K in keyof S]: S[K] extends Type<infer T> ? T : never }
-
-export class SelectBuilder<Row, Shape = unknown> {
-  private _state: SelectState
-
-  constructor(state: SelectState) {
-    this._state = state
-  }
-
-  from<N extends string, S extends TableShape>(
-    t: TableColumns<N, S>,
-  ): SelectBuilder<Row extends void ? ShapeRow<S> : Row, S> {
-    this._state.from = t
-    return this as any
-  }
-
-  pick<K extends Extract<keyof Shape, string>>(
-    ...keys: K[]
-  ): SelectBuilder<{ [P in K]: Shape[P] extends Type<infer T> ? T : never }, Shape> {
-    if (!this._state.from)
-      throw new Error('pick: from() must be called first')
-    const sel: Record<string, Column> = {}
-    for (const k of keys) sel[k] = (this._state.from as any)[k]
-    this._state.selection = sel
-    return this as any
-  }
-
-  where(expr: Expr): this {
-    this._state.where = expr
-    return this
-  }
-
-  orderBy(col: Column, dir: 'ASC' | 'DESC' = 'ASC'): this {
-    this._state.orderBy.push({ col, dir })
-    return this
-  }
-
-  limit(n: number): this {
-    this._state.limit = n
-    return this
-  }
-
-  offset(n: number): this {
-    this._state.offset = n
-    return this
-  }
-
-  toSQL(): CompiledQuery<Row> {
-    const s = this._state
-    if (!s.from)
-      throw new Error('select: from() is required')
-
-    const tableName = s.from._name
-    const params: unknown[] = []
-    const selectRefs: Column[] = []
-    const whereRefs: Column[] = []
-    const orderByRefs: Column[] = []
-
-    let cols: string
-    if (s.selection) {
-      const parts: string[] = []
-      for (const [alias, col] of Object.entries(s.selection)) {
-        selectRefs.push(col)
-        const ident = `"${col._table}"."${col._name}"`
-        parts.push(alias === col._name ? ident : `${ident} AS "${alias}"`)
-      }
-      cols = parts.join(', ')
-    }
-    else {
-      const shape = s.from._shape
-      const names = Object.keys(shape)
-      for (const n of names) selectRefs.push((s.from as any)[n])
-      cols = names.map(n => `"${tableName}"."${n}"`).join(', ')
-    }
-
-    let sql = `SELECT ${cols} FROM "${tableName}"`
-
-    if (s.where) {
-      sql += ` WHERE ${s.where.sql}`
-      params.push(...s.where.params)
-      whereRefs.push(...s.where.refs)
-    }
-
-    if (s.orderBy.length) {
-      const parts = s.orderBy.map((o) => {
-        orderByRefs.push(o.col)
-        return `"${o.col._table}"."${o.col._name}" ${o.dir}`
-      })
-      sql += ` ORDER BY ${parts.join(', ')}`
-    }
-
-    if (s.limit != null) {
-      sql += ` LIMIT ?`
-      params.push(s.limit)
-    }
-
-    if (s.offset != null) {
-      sql += ` OFFSET ?`
-      params.push(s.offset)
-    }
-
-    return {
-      sql,
-      params,
-      dependencies: collectDependencies(selectRefs, whereRefs, orderByRefs),
-      __row: undefined as any,
-    }
-  }
-
-  dependencies(): readonly QueryDependencies[] {
-    return this.toSQL().dependencies
-  }
-}
-
-function collectDependencies(
-  selectRefs: Column[],
-  whereRefs: Column[],
-  orderByRefs: Column[],
-): QueryDependencies[] {
-  interface Buckets {
-    select: Set<string>
-    where: Set<string>
-    orderBy: Set<string>
-  }
-  const map = new Map<string, Buckets>()
-  const bucket = (table: string): Buckets => {
-    let b = map.get(table)
-    if (!b) {
-      b = { select: new Set(), where: new Set(), orderBy: new Set() }
-      map.set(table, b)
-    }
-    return b
-  }
-  for (const c of selectRefs) bucket(c._table).select.add(c._name)
-  for (const c of whereRefs) bucket(c._table).where.add(c._name)
-  for (const c of orderByRefs) bucket(c._table).orderBy.add(c._name)
-
-  return Array.from(map, ([table, b]) => {
-    const all = new Set<string>([...b.select, ...b.where, ...b.orderBy])
-    return {
-      table,
-      select: Array.from(b.select).sort(),
-      where: Array.from(b.where).sort(),
-      orderBy: Array.from(b.orderBy).sort(),
-      all: Array.from(all).sort(),
-    }
-  })
-}
-
-export function select(): SelectBuilder<void>
-export function select<S extends Record<string, Column<any>>>(
-  selection: S,
-): SelectBuilder<RowFromSelection<S>>
-export function select(selection?: Record<string, Column>): SelectBuilder<any> {
-  return new SelectBuilder({ selection, orderBy: [] })
-}
-
-export function from<N extends string, S extends TableShape>(
-  t: TableColumns<N, S>,
-): SelectBuilder<ShapeRow<S>, S> {
-  return new SelectBuilder<ShapeRow<S>, S>({ from: t, orderBy: [] })
-}
-
-export type InferRow<Q> = Q extends SelectBuilder<infer R>
-  ? R
-  : Q extends CompiledQuery<infer R> ? R : never

package/src/common/schema/sql/table.ts

@@ -1,36 +0,0 @@
-import type { Infer, Type } from '../schema'
-
-export interface Column<T = unknown> {
-  readonly _table: string
-  readonly _name: string
-  readonly _type: Type<T>
-  readonly __row?: T
-}
-
-export type TableShape = Record<string, Type<any>>
-
-export type TableColumns<N extends string, S extends TableShape> = {
-  readonly [K in keyof S & string]: Column<Infer<S[K]>>
-} & {
-  readonly _name: N
-  readonly _shape: S
-}
-
-export function table<N extends string, S extends TableShape>(
-  name: N,
-  shape: S,
-): TableColumns<N, S> {
-  const out: any = { _name: name, _shape: shape }
-  for (const key of Object.keys(shape)) {
-    out[key] = {
-      _table: name,
-      _name: key,
-      _type: shape[key],
-    }
-  }
-  return out
-}
-
-export function isColumn(v: any): v is Column {
-  return !!v && typeof v._table === 'string' && typeof v._name === 'string' && v._type
-}