@livestore/livestore 0.4.0-dev.21 → 0.4.0-dev.23

package/docs/patterns/effect/index.md

@@ -1,1495 +0,0 @@
-# Effect
-
-LiveStore itself is built on top of [Effect](https://effect.website) which is a powerful library to write production-grade TypeScript code. It's also possible (and recommended) to use Effect directly in your application code.
-
-## Schema
-
-LiveStore uses the [Effect Schema](https://effect.website/docs/schema/introduction/) library to define schemas for the following:
-
-- Read model table column definitions
-- Event event payloads definitions
-- Query response types
-
-For convenience, LiveStore re-exports the `Schema` module from the `effect` package, which is the same as if you'd import it via `import { Schema } from 'effect'` directly.
-
-## `Equal` and `Hash` Traits
-
-LiveStore's reactive primitives (`LiveQueryDef` and `SignalDef`) implement Effect's `Equal` and `Hash` traits, enabling efficient integration with Effect's data structures and collections.
-
-## Effect atom integration
-
-LiveStore integrates seamlessly with [Effect Atom](https://github.com/effect-atom/effect-atom) for reactive state management in React applications. This provides a powerful combination of Effect's functional programming capabilities with LiveStore's event sourcing and CQRS patterns.
-
-Effect Atom is an external package developed by [Tim Smart](https://github.com/tim-smart) that provides a more Effect-idiomatic alternative to the `@livestore/react` package. While `@livestore/react` offers a straightforward React integration, Effect Atom leverages Effect API/patterns throughout, making it a natural choice for applications already using Effect.
-
-### Installation
-
-```bash
-pnpm install @effect-atom/atom-livestore @effect-atom/atom-react
-```
-
-### Store creation
-
-Create a LiveStore-backed atom store with persistence and worker support using the `AtomLivestore.Tag` pattern:
-
-## `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-The `StoreTag` class provides the following static methods:
-- `StoreTag.runtime` - Access to Effect runtime
-- `StoreTag.commit` - Commit events to the store
-- `StoreTag.store` - Access store with Effect
-- `StoreTag.storeUnsafe` - Direct store access when store is already loaded (synchronous)
-- `StoreTag.makeQuery` - Create query atoms with Effect
-- `StoreTag.makeQueryUnsafe` - Create query atoms without Effect
-
-### Defining query atoms
-
-Create reactive query atoms that automatically update when the underlying data changes:
-
-## `patterns/effect/store-setup/queries.ts`
-
-```ts filename="patterns/effect/store-setup/queries.ts"
-
-// User schema for type safety
-const User = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  isActive: Schema.Boolean,
-})
-
-const Product = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  createdAt: Schema.DateTimeUtc,
-})
-
-// Search term atom for dynamic queries
-export const searchTermAtom = Atom.make<string>('')
-
-// Re-export from utils for convenience
-export { usersQueryAtom as usersAtom } from './utils.ts'
-
-// Query with SQL
-export const activeUsersAtom = StoreTag.makeQuery(
-  queryDb({
-    query: sql`SELECT * FROM users WHERE isActive = true ORDER BY name`,
-    schema: Schema.Array(User),
-  }),
-)
-
-// Static query example - dynamic queries would need a different approach
-// For dynamic queries, you'd typically use a derived atom that depends on searchTermAtom
-export const searchResultsAtom = StoreTag.makeQuery(
-  queryDb({
-    query: sql`SELECT * FROM products ORDER BY createdAt DESC`,
-    schema: Schema.Array(Product),
-  }),
-)
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### `patterns/effect/store-setup/utils.ts`
-
-```ts filename="patterns/effect/store-setup/utils.ts"
-
-// Common query atoms that can be reused
-export const todosQueryAtom = StoreTag.makeQuery(queryDb(tables.todos))
-export const todosQueryUnsafeAtom = StoreTag.makeQueryUnsafe(queryDb(tables.todos))
-export const usersQueryAtom = StoreTag.makeQuery(queryDb(tables.users))
-export const productsQueryAtom = StoreTag.makeQuery(queryDb(tables.products))
-
-// Common types for optimistic updates
-export type PendingTodo = { id: string; text: string; completed: boolean }
-export type PendingUser = { id: string; name: string; email: string }
-
-// Common pending state atoms
-export const pendingTodosAtom = Atom.make<PendingTodo[]>([])
-export const pendingUsersAtom = Atom.make<PendingUser[]>([])
-```
-
-### Using queries in React components
-
-Access query results in React components with the `useAtomValue` hook. When using `StoreTag.makeQuery` (non-unsafe API), the result is wrapped in a Result type for proper loading and error handling:
-
-## `patterns/effect/store-setup/user-list.tsx`
-
-```tsx filename="patterns/effect/store-setup/user-list.tsx"
-
-export function UserList() {
-  const users = useAtomValue(activeUsersAtom)
-
-  return Result.builder(users)
-    .onInitial(() => <div>Loading users...</div>)
-    .onSuccess((users) => (
-      <ul>
-        {users.map((user) => (
-          <li key={user.id}>{user.name}</li>
-        ))}
-      </ul>
-    ))
-    .onDefect((error: any) => <div>Error: {error.message}</div>)
-    .render()
-}
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/queries.ts`
-
-```ts filename="patterns/effect/store-setup/queries.ts"
-
-// User schema for type safety
-const User = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  isActive: Schema.Boolean,
-})
-
-const Product = Schema.Struct({
-  id: Schema.String,
-  name: Schema.String,
-  createdAt: Schema.DateTimeUtc,
-})
-
-// Search term atom for dynamic queries
-export const searchTermAtom = Atom.make<string>('')
-
-// Re-export from utils for convenience
-export { usersQueryAtom as usersAtom } from './utils.ts'
-
-// Query with SQL
-export const activeUsersAtom = StoreTag.makeQuery(
-  queryDb({
-    query: sql`SELECT * FROM users WHERE isActive = true ORDER BY name`,
-    schema: Schema.Array(User),
-  }),
-)
-
-// Static query example - dynamic queries would need a different approach
-// For dynamic queries, you'd typically use a derived atom that depends on searchTermAtom
-export const searchResultsAtom = StoreTag.makeQuery(
-  queryDb({
-    query: sql`SELECT * FROM products ORDER BY createdAt DESC`,
-    schema: Schema.Array(Product),
-  }),
-)
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### `patterns/effect/store-setup/utils.ts`
-
-```ts filename="patterns/effect/store-setup/utils.ts"
-
-// Common query atoms that can be reused
-export const todosQueryAtom = StoreTag.makeQuery(queryDb(tables.todos))
-export const todosQueryUnsafeAtom = StoreTag.makeQueryUnsafe(queryDb(tables.todos))
-export const usersQueryAtom = StoreTag.makeQuery(queryDb(tables.users))
-export const productsQueryAtom = StoreTag.makeQuery(queryDb(tables.products))
-
-// Common types for optimistic updates
-export type PendingTodo = { id: string; text: string; completed: boolean }
-export type PendingUser = { id: string; name: string; email: string }
-
-// Common pending state atoms
-export const pendingTodosAtom = Atom.make<PendingTodo[]>([])
-export const pendingUsersAtom = Atom.make<PendingUser[]>([])
-```
-
-### Integrating Effect services
-
-Combine Effect services with LiveStore operations using the store's runtime:
-
-## `patterns/effect/store-setup/services.tsx`
-
-```tsx filename="patterns/effect/store-setup/services.tsx"
-
-// Example service definition
-export class MyService extends Context.Tag('MyService')<
-  MyService,
-  {
-    processItem: (name: string) => Effect.Effect<{
-      name: string
-      metadata: Record<string, unknown>
-    }>
-  }
->() {}
-
-// Use the commit hook for event handling
-export const useCommit = () => useAtomSet(StoreTag.commit)
-
-// Simple commit example
-export const createItemAtom = StoreTag.runtime.fn<string>()((itemName, get) => {
-  return Effect.sync(() => {
-    const store = get(StoreTag.storeUnsafe)
-    if (store) {
-      store.commit(
-        events.itemCreated({
-          id: crypto.randomUUID(),
-          name: itemName,
-          metadata: { createdAt: new Date().toISOString() },
-        }),
-      )
-    }
-  })
-})
-
-// Use in a React component
-export function CreateItemButton() {
-  const createItem = useAtomSet(createItemAtom)
-
-  const handleClick = () => {
-    createItem('New Item')
-  }
-
-  return (
-    <button type="button" onClick={handleClick}>
-      Create Item
-    </button>
-  )
-}
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### Advanced patterns
-
-#### Optimistic updates
-
-Combine local state with LiveStore for optimistic UI updates. When using `StoreTag.makeQueryUnsafe`, the data is directly available:
-
-## `patterns/effect/optimistic-example/optimistic.ts`
-
-```ts filename="patterns/effect/optimistic-example/optimistic.ts"
-
-// Combine real and pending todos for optimistic UI
-export const optimisticTodoAtom = Atom.make((get) => {
-  const todos = get(todosQueryUnsafeAtom) // Direct array, not wrapped in Result
-  const pending = get(pendingTodosAtom)
-
-  return [...(todos || []), ...pending]
-})
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### `patterns/effect/store-setup/utils.ts`
-
-```ts filename="patterns/effect/store-setup/utils.ts"
-
-// Common query atoms that can be reused
-export const todosQueryAtom = StoreTag.makeQuery(queryDb(tables.todos))
-export const todosQueryUnsafeAtom = StoreTag.makeQueryUnsafe(queryDb(tables.todos))
-export const usersQueryAtom = StoreTag.makeQuery(queryDb(tables.users))
-export const productsQueryAtom = StoreTag.makeQuery(queryDb(tables.products))
-
-// Common types for optimistic updates
-export type PendingTodo = { id: string; text: string; completed: boolean }
-export type PendingUser = { id: string; name: string; email: string }
-
-// Common pending state atoms
-export const pendingTodosAtom = Atom.make<PendingTodo[]>([])
-export const pendingUsersAtom = Atom.make<PendingUser[]>([])
-```
-
-#### Derived state
-
-Create computed atoms based on LiveStore queries. When using the non-unsafe API, handle the Result type:
-
-## `patterns/effect/derived-example/derived.ts`
-
-```ts filename="patterns/effect/derived-example/derived.ts"
-
-// Derive statistics from todos
-export const todoStatsAtom = Atom.make((get) => {
-  const todos = get(todosQueryAtom) // Result wrapped
-
-  return Result.map(todos, (todoList) => ({
-    total: todoList.length,
-    completed: todoList.filter((t) => t.completed).length,
-    pending: todoList.filter((t) => !t.completed).length,
-  }))
-})
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### `patterns/effect/store-setup/utils.ts`
-
-```ts filename="patterns/effect/store-setup/utils.ts"
-
-// Common query atoms that can be reused
-export const todosQueryAtom = StoreTag.makeQuery(queryDb(tables.todos))
-export const todosQueryUnsafeAtom = StoreTag.makeQueryUnsafe(queryDb(tables.todos))
-export const usersQueryAtom = StoreTag.makeQuery(queryDb(tables.users))
-export const productsQueryAtom = StoreTag.makeQuery(queryDb(tables.products))
-
-// Common types for optimistic updates
-export type PendingTodo = { id: string; text: string; completed: boolean }
-export type PendingUser = { id: string; name: string; email: string }
-
-// Common pending state atoms
-export const pendingTodosAtom = Atom.make<PendingTodo[]>([])
-export const pendingUsersAtom = Atom.make<PendingUser[]>([])
-```
-
-#### Batch operations
-
-Perform multiple commits efficiently (commits are synchronous):
-
-## `patterns/effect/batch-example/batch.ts`
-
-```ts filename="patterns/effect/batch-example/batch.ts"
-
-// Bulk update atom for batch operations
-export const bulkUpdateAtom = StoreTag.runtime.fn<string[]>()(
-  Effect.fn(function* (ids, get) {
-    const store = get(StoreTag.storeUnsafe)
-    if (!store) return
-
-    // Commit multiple events synchronously
-    for (const id of ids) {
-      store.commit(events.itemUpdated({ id, status: 'processed' }))
-    }
-  }),
-)
-```
-
-### `patterns/effect/store-setup/atoms.ts`
-
-```ts filename="patterns/effect/store-setup/atoms.ts"
-
-export { schema } from './schema.ts'
-
-// Create a persistent adapter with OPFS storage
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker: LiveStoreWorker,
-  sharedWorker: LiveStoreSharedWorker,
-})
-
-// Define the store as a service tag
-export class StoreTag extends AtomLivestore.Tag<StoreTag>()('StoreTag', {
-  schema,
-  storeId: 'default',
-  adapter,
-  batchUpdates: unstable_batchedUpdates, // React batching for performance
-}) {}
-```
-
-### `patterns/effect/store-setup/schema.ts`
-
-```ts filename="patterns/effect/store-setup/schema.ts"
-
-// Define event payloads
-export const events = {
-  userCreated: Events.clientOnly({
-    name: 'userCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      email: Schema.String,
-    }),
-  }),
-  userUpdated: Events.clientOnly({
-    name: 'userUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      email: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      isActive: Schema.optionalWith(Schema.Boolean, { as: 'Option' }),
-    }),
-  }),
-  productCreated: Events.clientOnly({
-    name: 'productCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      description: Schema.String,
-      price: Schema.Number,
-    }),
-  }),
-  productUpdated: Events.clientOnly({
-    name: 'productUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      description: Schema.optionalWith(Schema.String, { as: 'Option' }),
-      price: Schema.optionalWith(Schema.Number, { as: 'Option' }),
-    }),
-  }),
-  todoCreated: Events.clientOnly({
-    name: 'todoCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      text: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  todoToggled: Events.clientOnly({
-    name: 'todoToggled',
-    schema: Schema.Struct({
-      id: Schema.String,
-      completed: Schema.Boolean,
-    }),
-  }),
-  itemCreated: Events.clientOnly({
-    name: 'itemCreated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      name: Schema.String,
-      metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
-    }),
-  }),
-  itemUpdated: Events.clientOnly({
-    name: 'itemUpdated',
-    schema: Schema.Struct({
-      id: Schema.String,
-      status: Schema.String,
-    }),
-  }),
-}
-
-// Define tables
-const tables = {
-  users: State.SQLite.table({
-    name: 'users',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      email: State.SQLite.text(),
-      isActive: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  products: State.SQLite.table({
-    name: 'products',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      name: State.SQLite.text(),
-      description: State.SQLite.text(),
-      price: State.SQLite.real(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean(),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-}
-
-// Define materializers
-const materializers = State.SQLite.materializers(events, {
-  userCreated: ({ id, name, email }) => tables.users.insert({ id, name, email, isActive: true, createdAt: new Date() }),
-  userUpdated: ({ id, name, email, isActive }) => {
-    const updates: { name?: string; email?: string; isActive?: boolean } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(email)) updates.email = email.value
-    if (Option.isSome(isActive)) updates.isActive = isActive.value
-    return tables.users.update(updates).where({ id })
-  },
-  todoCreated: ({ id, text, completed }) => tables.todos.insert({ id, text, completed, createdAt: new Date() }),
-  todoToggled: ({ id, completed }) => tables.todos.update({ completed }).where({ id }),
-  productCreated: ({ id, name, description, price }) =>
-    tables.products.insert({ id, name, description, price, createdAt: new Date() }),
-  productUpdated: ({ id, name, description, price }) => {
-    const updates: { name?: string; description?: string; price?: number } = {}
-    if (Option.isSome(name)) updates.name = name.value
-    if (Option.isSome(description)) updates.description = description.value
-    if (Option.isSome(price)) updates.price = price.value
-    return tables.products.update(updates).where({ id })
-  },
-  itemCreated: () => [], // Item events don't have a corresponding table
-  itemUpdated: () => [], // Item events don't have a corresponding table
-})
-
-// Create state
-const state = State.SQLite.makeState({ tables, materializers })
-
-// Create the store schema
-export const schema = makeSchema({ events, state })
-
-export { tables }
-```
-
-### Best practices
-
-1. **Use `StoreTag.makeQuery` for queries**: This ensures proper Effect integration and error handling
-2. **Leverage Effect services**: Integrate business logic through Effect services for better testability
-3. **Handle loading states**: Use `Result.builder` pattern for consistent loading/error UI
-4. **Batch React updates**: Always provide `batchUpdates` for better performance
-5. **Label queries**: Add descriptive labels to queries for better debugging
-6. **Type safety**: Let TypeScript infer types from schemas rather than manual annotations
-
-### Real-World Example
-
-For a comprehensive example of LiveStore with Effect Atom in action, check out [Cheffect](https://github.com/tim-smart/cheffect) - a recipe management application that demonstrates:
-- Complete Effect service integration
-- AI-powered recipe extraction using Effect services
-- Complex query patterns with search and filtering
-- Worker-based persistence with OPFS
-- Production-ready error handling and logging