@livestore/common 0.0.53 → 0.0.54-dev.1

package/dist/util.d.ts

@@ -1,8 +1,11 @@
 /// <reference lib="es2022" />
 import type { Brand } from '@livestore/utils/effect';
+import { Schema } from '@livestore/utils/effect';
 export type ParamsObject = Record<string, SqlValue>;
 export type SqlValue = string | number | Uint8Array | null;
-export type Bindable = SqlValue[] | ParamsObject;
+export type Bindable = ReadonlyArray<SqlValue> | ParamsObject;
+export declare const SqlValueSchema: Schema.Union<[typeof Schema.String, typeof Schema.Number, Schema.Schema<Uint8Array, readonly number[], never>, typeof Schema.Null]>;
+export declare const PreparedBindValues: Schema.brand<Schema.Union<[Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, Schema.Schema<Uint8Array, readonly number[], never>, typeof Schema.Null]>>, Schema.Record$<typeof Schema.String, Schema.Union<[typeof Schema.String, typeof Schema.Number, Schema.Schema<Uint8Array, readonly number[], never>, typeof Schema.Null]>>]>, "PreparedBindValues">;
 export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>;
 /**
  * This is a tag function for tagged literals.

package/dist/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAEpD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACnD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI,CAAA;AAE1D,MAAM,MAAM,QAAQ,GAAG,QAAQ,EAAE,GAAG,YAAY,CAAA;AAEhD,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAA;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,GAAG,aAAc,oBAAoB,WAAW,OAAO,EAAE,KAAG,MASxE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,WAAY,QAAQ,aAAa,MAAM,KAAG,kBAWvE,CAAA"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEhD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;AACnD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI,CAAA;AAE1D,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC,GAAG,YAAY,CAAA;AAE7D,eAAO,MAAM,cAAc,qIAA6E,CAAA;AAExG,eAAO,MAAM,kBAAkB,mXAGW,CAAA;AAE1C,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAA;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,GAAG,aAAc,oBAAoB,WAAW,OAAO,EAAE,KAAG,MASxE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,WAAY,QAAQ,aAAa,MAAM,KAAG,kBAWvE,CAAA"}

package/dist/util.js

@@ -1,4 +1,7 @@
 /// <reference lib="es2022" />
+import { Schema } from '@livestore/utils/effect';
+export const SqlValueSchema = Schema.Union(Schema.String, Schema.Number, Schema.Uint8Array, Schema.Null);
+export const PreparedBindValues = Schema.Union(Schema.Array(SqlValueSchema), Schema.Record(Schema.String, SqlValueSchema)).pipe(Schema.brand('PreparedBindValues'));
 /**
  * This is a tag function for tagged literals.
  * it lets us get syntax highlighting on SQL queries in VSCode, but

package/dist/util.js.map

@@ -1 +1 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAW9B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,QAA8B,EAAE,GAAG,IAAe,EAAU,EAAE;IAChF,IAAI,GAAG,GAAG,EAAE,CAAA;IAEZ,KAAK,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;QACtC,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;IAClC,CAAC;IAED,6CAA6C;IAC7C,OAAO,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AAC5C,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAgB,EAAE,SAAiB,EAAsB,EAAE;IAC3F,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,OAAO,MAA4B,CAAA;IAE9D,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,KAAK,CAAA;QAC3B,CAAC;IACH,CAAC;IAED,OAAO,MAA4B,CAAA;AACrC,CAAC,CAAA"}
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAG9B,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAOhD,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;AAExG,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,KAAK,CAC5C,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,EAC5B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAC7C,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAA;AAI1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,QAA8B,EAAE,GAAG,IAAe,EAAU,EAAE;IAChF,IAAI,GAAG,GAAG,EAAE,CAAA;IAEZ,KAAK,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;QACtC,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;IAClC,CAAC;IAED,6CAA6C;IAC7C,OAAO,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AAC5C,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,MAAgB,EAAE,SAAiB,EAAsB,EAAE;IAC3F,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QAAE,OAAO,MAAmC,CAAA;IAErE,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,KAAK,CAAA;QAC3B,CAAC;IACH,CAAC;IAED,OAAO,MAA4B,CAAA;AACrC,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/common",
-  "version": "0.0.53",
+  "version": "0.0.54-dev.1",
   "type": "module",
   "exports": {
     ".": {
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@livestore/utils": "0.0.53",
-    "effect-db-schema": "0.0.53"
+    "@livestore/utils": "0.0.54-dev.1",
+    "effect-db-schema": "0.0.54-dev.1"
   },
   "devDependencies": {
     "vitest": "^1.6.0"

package/src/adapter-types.ts

@@ -1,4 +1,5 @@
 import type { Stream, SubscriptionRef, TRef } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 
 import type { LiveStoreSchema, MutationEvent } from './schema/index.js'
@@ -27,12 +28,20 @@ export type InMemoryDatabase = {
 
 export type ResetMode = 'all-data' | 'only-app-db'
 
+export const NetworkStatus = Schema.Struct({
+  isConnected: Schema.Boolean,
+  timestampMs: Schema.Number,
+})
+
 export type NetworkStatus = {
   isConnected: boolean
   timestampMs: number
 }
 
 export type Coordinator = {
+  devtools: {
+    channelId: string
+  }
   hasLock: TRef.TRef<boolean>
   syncMutations: Stream.Stream<MutationEvent.AnyEncoded>
   execute(queryStr: string, bindValues: PreparedBindValues | undefined, span: otel.Span | undefined): Promise<void>

package/src/bounded-collections.ts

@@ -0,0 +1,121 @@
+/**
+ * Creates a map that has a fixed number of entries.
+ * Once hitting the bound, earliest insertions are removed
+ */
+export class BoundMap<K, V> {
+  #map = new Map<K, V>()
+  #sizeLimit: number
+
+  constructor(sizeLimit: number) {
+    this.#sizeLimit = sizeLimit
+  }
+
+  onEvict: ((key: K, value: V) => void) | undefined
+
+  set = (key: K, value: V) => {
+    this.#map.set(key, value)
+    // console.log(this.#map.size, this.#sizeLimit);
+    if (this.#map.size > this.#sizeLimit) {
+      const firstKey = this.#map.keys().next().value
+      const deletedValue = this.#map.get(firstKey)!
+      this.#map.delete(firstKey)
+      if (this.onEvict) {
+        this.onEvict(firstKey, deletedValue)
+      }
+    }
+  }
+
+  get = (key: K): V | undefined => {
+    return this.#map.get(key)
+  }
+
+  delete = (key: K) => {
+    this.#map.delete(key)
+  }
+
+  keys = () => {
+    return this.#map.keys()
+  }
+}
+
+export class BoundSet<V> {
+  #map: BoundMap<V, V>
+
+  constructor(sizeLimit: number) {
+    this.#map = new BoundMap(sizeLimit)
+    this.#map.onEvict = this.#onEvict
+  }
+
+  #onEvict = (v: V) => {
+    if (this.onEvict) {
+      this.onEvict(v)
+    }
+  }
+
+  onEvict: ((key: V) => void) | undefined
+
+  add = (v: V) => {
+    this.#map.set(v, v)
+  };
+
+  [Symbol.iterator] = () => {
+    return this.#map.keys()
+  }
+}
+
+export class BoundArray<V> {
+  #array: V[] = []
+  public sizeLimit: number
+
+  constructor(sizeLimit: number) {
+    this.sizeLimit = sizeLimit
+  }
+
+  static make = <V>(sizeLimit: number, initial: ReadonlyArray<V> = []): BoundArray<V> => {
+    const b = new BoundArray<V>(sizeLimit)
+    for (const v of initial) {
+      b.push(v)
+    }
+    return b
+  }
+
+  onEvict: ((key: V) => void) | undefined
+
+  push = (v: V) => {
+    this.#array.push(v)
+    if (this.#array.length > this.sizeLimit) {
+      const first = this.#array.shift()
+      if (first && this.onEvict) {
+        this.onEvict(first)
+      }
+    }
+  }
+
+  get = (index: number): V | undefined => {
+    return this.#array[index]
+  }
+
+  delete = (index: number) => {
+    this.#array.splice(index, 1)
+  }
+
+  get length() {
+    return this.#array.length
+  }
+
+  [Symbol.iterator] = (): IterableIterator<V> => {
+    return this.#array[Symbol.iterator]()
+  }
+
+  map = <T>(fn: (v: V) => T): T[] => {
+    return this.#array.map(fn)
+  }
+
+  clear = () => {
+    this.#array = []
+  }
+
+  sort = (fn?: (a: V, b: V) => number) => {
+    return this.#array.sort(fn)
+  }
+}

package/src/debug-info.ts

@@ -0,0 +1,88 @@
+import { ParseResult, Schema } from '@livestore/utils/effect'
+
+import { BoundArray } from './bounded-collections.js'
+import { PreparedBindValues } from './util.js'
+
+export type SlowQueryInfo = {
+  queryStr: string
+  bindValues: PreparedBindValues | undefined
+  durationMs: number
+  rowsCount: number | undefined
+  queriedTables: Set<string>
+  startTimePerfNow: DOMHighResTimeStamp
+}
+
+export const SlowQueryInfo = Schema.Struct({
+  queryStr: Schema.String,
+  bindValues: Schema.UndefinedOr(PreparedBindValues),
+  durationMs: Schema.Number,
+  rowsCount: Schema.UndefinedOr(Schema.Number),
+  queriedTables: Schema.ReadonlySet(Schema.String),
+  startTimePerfNow: Schema.Number,
+})
+
+const BoundArraySchemaFromSelf = <ItemDecoded, ItemEncoded>(_elSchema: Schema.Schema<ItemDecoded, ItemEncoded>) =>
+  Schema.declare((_): _ is BoundArray<ItemDecoded> => _ instanceof BoundArray, {
+    identifier: `BoundArrayFromSelf`,
+    pretty: () => (_) => `BoundArray(${_.length})`,
+    arbitrary: () => (fc) => fc.anything() as any,
+    equivalence: () => (a, b) => a === b,
+  }) as any as Schema.Schema<BoundArray<ItemDecoded>, BoundArray<ItemEncoded>>
+
+const BoundArraySchemaFromSelf_ = <A, I, R>(
+  item: Schema.Schema<A, I, R>,
+): Schema.Schema<BoundArray<A>, BoundArray<I>, R> =>
+  Schema.declare(
+    [item],
+    {
+      decode: (item) => (input, parseOptions, ast) => {
+        if (input instanceof BoundArray) {
+          const elements = ParseResult.decodeUnknown(Schema.Array(item))([...input], parseOptions)
+          return ParseResult.map(elements, (as): BoundArray<A> => BoundArray.make(input.sizeLimit, as))
+        }
+        return ParseResult.fail(new ParseResult.Type(ast, input))
+      },
+      encode: (item) => (input, parseOptions, ast) => {
+        if (input instanceof BoundArray) {
+          const elements = ParseResult.encodeUnknown(Schema.Array(item))([...input], parseOptions)
+          return ParseResult.map(elements, (is): BoundArray<I> => BoundArray.make(input.sizeLimit, is))
+        }
+        return ParseResult.fail(new ParseResult.Type(ast, input))
+      },
+    },
+    {
+      description: `BoundArray<${Schema.format(item)}>`,
+    },
+  )
+
+const BoundArraySchema = <ItemDecoded, ItemEncoded>(elSchema: Schema.Schema<ItemDecoded, ItemEncoded>) =>
+  Schema.transform(
+    Schema.Struct({
+      size: Schema.Number,
+      items: Schema.Array(elSchema),
+    }),
+    BoundArraySchemaFromSelf(elSchema as any as Schema.Schema<ItemDecoded>),
+    {
+      encode: (_) => ({ size: _.sizeLimit, items: [..._] }),
+      decode: (_) => BoundArray.make(_.size, _.items),
+    },
+  )
+
+export const DebugInfo = Schema.Struct({
+  slowQueries: BoundArraySchema(SlowQueryInfo),
+  queryFrameDuration: Schema.Number,
+  queryFrameCount: Schema.Number,
+  events: BoundArraySchema(Schema.Tuple(Schema.String, Schema.Any)),
+})
+
+// export interface DebugInfo {
+//   slowQueries: BoundArray<SlowQueryInfo>
+//   queryFrameDuration: number
+//   queryFrameCount: number
+//   events: BoundArray<[queryStr: string, bindValues: Bindable | undefined]>
+// }
+
+export type DebugInfo = typeof DebugInfo.Type
+
+export const MutableDebugInfo = Schema.mutable(DebugInfo)
+export type MutableDebugInfo = typeof MutableDebugInfo.Type

package/src/devtools/devtools-messages.ts

@@ -0,0 +1,186 @@
+import { Schema } from '@livestore/utils/effect'
+import { type SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+
+import { NetworkStatus } from '../adapter-types.js'
+import { DebugInfo } from '../debug-info.js'
+import { mutationEventSchemaEncodedAny } from '../schema/mutations.js'
+import { PreparedBindValues } from '../util.js'
+
+const requestId = Schema.String
+const channelId = Schema.String
+
+export class SnapshotReq extends Schema.TaggedStruct('LSD.SnapshotReq', {
+  requestId,
+  channelId,
+}) {}
+
+export class SnapshotRes extends Schema.TaggedStruct('LSD.SnapshotRes', {
+  requestId,
+  snapshot: Schema.Uint8Array,
+}) {}
+
+export class DebugInfoReq extends Schema.TaggedStruct('LSD.DebugInfoReq', {
+  requestId,
+  channelId,
+}) {}
+
+export class DebugInfoRes extends Schema.TaggedStruct('LSD.DebugInfoRes', {
+  requestId,
+  debugInfo: DebugInfo,
+}) {}
+
+export class DebugInfoResetReq extends Schema.TaggedStruct('LSD.DebugInfoResetReq', {
+  requestId,
+  channelId,
+}) {}
+
+export class DebugInfoResetRes extends Schema.TaggedStruct('LSD.DebugInfoResetRes', {
+  requestId,
+}) {}
+
+export class DebugInfoRerunQueryReq extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryReq', {
+  requestId,
+  channelId,
+  queryStr: Schema.String,
+  bindValues: Schema.UndefinedOr(PreparedBindValues),
+  queriedTables: Schema.ReadonlySet(Schema.String),
+}) {}
+
+export class DebugInfoRerunQueryRes extends Schema.TaggedStruct('LSD.DebugInfoRerunQueryRes', {
+  requestId,
+}) {}
+
+export class MutationBroadcast extends Schema.TaggedStruct('LSD.MutationBroadcast', {
+  requestId,
+  mutationEventEncoded: mutationEventSchemaEncodedAny,
+  persisted: Schema.Boolean,
+}) {}
+
+export class MutationLogReq extends Schema.TaggedStruct('LSD.MutationLogReq', {
+  requestId,
+  channelId,
+}) {}
+
+export class MutationLogRes extends Schema.TaggedStruct('LSD.MutationLogRes', {
+  requestId,
+  mutationLog: Schema.Uint8Array,
+}) {}
+
+export class SignalsSubscribe extends Schema.TaggedStruct('LSD.SignalsSubscribe', {
+  requestId,
+  channelId,
+  includeResults: Schema.Boolean,
+}) {}
+
+export class SignalsUnsubscribe extends Schema.TaggedStruct('LSD.SignalsUnsubscribe', {
+  requestId,
+  channelId,
+}) {}
+
+export class SignalsRes extends Schema.TaggedStruct('LSD.SignalsRes', {
+  requestId,
+  signals: Schema.Any,
+}) {}
+
+export class LiveQueriesSubscribe extends Schema.TaggedStruct('LSD.LiveQueriesSubscribe', {
+  requestId,
+  channelId,
+}) {}
+
+export class LiveQueriesUnsubscribe extends Schema.TaggedStruct('LSD.LiveQueriesUnsubscribe', {
+  requestId,
+  channelId,
+}) {}
+
+export class SerializedLiveQuery extends Schema.Struct({
+  _tag: Schema.Literal('js', 'sql', 'graphql'),
+  id: Schema.Number,
+  label: Schema.String,
+  runs: Schema.Number,
+  executionTimes: Schema.Array(Schema.Number),
+  lastestResult: Schema.Any,
+  activeSubscriptions: Schema.Array(
+    Schema.Struct({ frames: Schema.Array(Schema.Struct({ name: Schema.String, filePath: Schema.String })) }),
+  ),
+}) {}
+
+export class LiveQueriesRes extends Schema.TaggedStruct('LSD.LiveQueriesRes', {
+  requestId,
+  liveQueries: Schema.Array(SerializedLiveQuery),
+}) {}
+
+export class ResetAllDataReq extends Schema.TaggedStruct('LSD.ResetAllDataReq', {
+  requestId,
+  channelId,
+  mode: Schema.Literal('all-data', 'only-app-db'),
+}) {}
+
+export class ResetAllDataRes extends Schema.TaggedStruct('LSD.ResetAllDataRes', {
+  requestId,
+}) {}
+
+export class NetworkStatusBroadcast extends Schema.TaggedStruct('LSD.NetworkStatusBroadcast', {
+  channelId,
+  networkStatus: NetworkStatus,
+}) {}
+
+export class DevtoolsReadyBroadcast extends Schema.TaggedStruct('LSD.DevtoolsReadyBroadcast', {}) {}
+
+export class DevtoolsConnected extends Schema.TaggedStruct('LSD.DevtoolsConnected', {
+  channelId,
+}) {}
+
+export class AppHostReadyBroadcast extends Schema.TaggedStruct('LSD.AppHostReadyBroadcast', {
+  channelId,
+}) {}
+
+export class Disconnect extends Schema.TaggedStruct('LSD.Disconnect', {
+  requestId,
+  channelId,
+}) {}
+
+// export class SchemaChanged extends Schema.TaggedStruct('LSD.SchemaChanged', {
+//   requestId,
+// }) {}
+
+export const MessageToAppHost = Schema.Union(
+  SnapshotReq,
+  MutationLogReq,
+  DebugInfoReq,
+  DebugInfoResetReq,
+  DebugInfoRerunQueryReq,
+  SignalsSubscribe,
+  SignalsUnsubscribe,
+  LiveQueriesSubscribe,
+  LiveQueriesUnsubscribe,
+  ResetAllDataReq,
+  DevtoolsReadyBroadcast,
+  Disconnect,
+  DevtoolsConnected,
+)
+
+export type MessageToAppHost = typeof MessageToAppHost.Type
+
+export const MessageFromAppHost = Schema.Union(
+  SnapshotRes,
+  MutationLogRes,
+  DebugInfoRes,
+  DebugInfoResetRes,
+  DebugInfoRerunQueryRes,
+  SignalsRes,
+  LiveQueriesRes,
+  ResetAllDataRes,
+  Disconnect,
+  // SchemaChanged,
+  MutationBroadcast,
+  AppHostReadyBroadcast,
+  NetworkStatusBroadcast,
+)
+
+export type MessageFromAppHost = typeof MessageFromAppHost.Type
+
+// TODO make specific over app key
+export const makeBroadcastChannels = () => ({
+  fromAppHost: new BroadcastChannel(`livestore-devtools-from-app-host`),
+  toAppHost: new BroadcastChannel(`livestore-devtools-to-app-host`),
+})

package/src/devtools/index.ts

@@ -0,0 +1 @@
+export * from './devtools-messages.js'

package/src/index.ts

@@ -8,3 +8,6 @@ export * from './rehydrate-from-mutationlog.js'
 export * from './query-info.js'
 export * from './derived-mutations.js'
 export * from './sync/index.js'
+export * as Devtools from './devtools/index.js'
+export * from './debug-info.js'
+export * from './bounded-collections.js'

package/src/schema/index.ts

@@ -1,6 +1,7 @@
 import { isReadonlyArray, shouldNeverHappen } from '@livestore/utils'
 import type { ReadonlyArray } from '@livestore/utils/effect'
-import { SqliteAst, type SqliteDsl } from 'effect-db-schema'
+import type { SqliteDsl } from 'effect-db-schema'
+import { SqliteAst } from 'effect-db-schema'
 
 import type { MigrationOptions } from '../adapter-types.js'
 import { makeDerivedMutationDefsForTable } from '../derived-mutations.js'
@@ -20,10 +21,14 @@ export * as ParseUtils from './parse-utils.js'
 export * from './mutations.js'
 export * from './schema-helpers.js'
 
+export const LiveStoreSchemaSymbol = Symbol.for('livestore.LiveStoreSchema')
+export type LiveStoreSchemaSymbol = typeof LiveStoreSchemaSymbol
+
 export type LiveStoreSchema<
   TDbSchema extends SqliteDsl.DbSchema = SqliteDsl.DbSchema,
   TMutationsDefRecord extends MutationDefRecord = MutationDefRecord,
 > = {
+  readonly _Type: LiveStoreSchemaSymbol
   /** Only used on type-level */
   readonly _DbSchemaType: TDbSchema
   /** Only used on type-level */
@@ -99,8 +104,9 @@ export const makeSchema = <TInputSchema extends InputSchema>(
   })
 
   return {
-    _DbSchemaType: Symbol('livestore.DbSchemaType') as any,
-    _MutationDefMapType: Symbol('livestore.MutationDefMapType') as any,
+    _Type: LiveStoreSchemaSymbol,
+    _DbSchemaType: Symbol.for('livestore.DbSchemaType') as any,
+    _MutationDefMapType: Symbol.for('livestore.MutationDefMapType') as any,
     tables,
     mutations,
     migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },

package/src/util.ts

@@ -1,11 +1,19 @@
 /// <reference lib="es2022" />
 
 import type { Brand } from '@livestore/utils/effect'
+import { Schema } from '@livestore/utils/effect'
 
 export type ParamsObject = Record<string, SqlValue>
 export type SqlValue = string | number | Uint8Array | null
 
-export type Bindable = SqlValue[] | ParamsObject
+export type Bindable = ReadonlyArray<SqlValue> | ParamsObject
+
+export const SqlValueSchema = Schema.Union(Schema.String, Schema.Number, Schema.Uint8Array, Schema.Null)
+
+export const PreparedBindValues = Schema.Union(
+  Schema.Array(SqlValueSchema),
+  Schema.Record(Schema.String, SqlValueSchema),
+).pipe(Schema.brand('PreparedBindValues'))
 
 export type PreparedBindValues = Brand.Branded<Bindable, 'PreparedBindValues'>
 
@@ -33,7 +41,7 @@ export const sql = (template: TemplateStringsArray, ...args: unknown[]): string
 /*  TODO: Search for unused params via proper parsing, not string search
 **/
 export const prepareBindValues = (values: Bindable, statement: string): PreparedBindValues => {
-  if (Array.isArray(values)) return values as PreparedBindValues
+  if (Array.isArray(values)) return values as any as PreparedBindValues
 
   const result: ParamsObject = {}
   for (const [key, value] of Object.entries(values)) {