@livestore/common 0.4.0 → 0.5.0-dev.0

package/src/make-client-session.ts

@@ -1,5 +1,4 @@
-import type { Scope, SubscriptionRef } from '@livestore/utils/effect'
-import { Effect, Stream } from '@livestore/utils/effect'
+import { type Scope, type SubscriptionRef, Effect, Latch, Stream } from '@livestore/utils/effect'
 import * as Webmesh from '@livestore/webmesh'
 
 import type {
@@ -51,9 +50,10 @@ export const makeClientSession = <R>({
   origin: string | undefined
 }): Effect.Effect<ClientSession, never, Scope.Scope | R> =>
   Effect.gen(function* () {
-    const devtools: ClientSession['devtools'] = devtoolsEnabled === true
-      ? { enabled: true, pullLatch: yield* Effect.makeLatch(true), pushLatch: yield* Effect.makeLatch(true) }
-      : { enabled: false }
+    const devtools: ClientSession['devtools'] =
+      devtoolsEnabled === true
+        ? { enabled: true, pullLatch: yield* Latch.make(true), pushLatch: yield* Latch.make(true) }
+        : { enabled: false }
 
     if (devtoolsEnabled === true) {
       yield* Effect.gen(function* () {
@@ -116,7 +116,7 @@ export const makeClientSession = <R>({
                 yield* connectDevtoolsToStore(clientSessionDevtoolsChannel)
               },
               Effect.tapCauseLogPretty,
-              Effect.forkScoped,
+              Effect.forkScoped(),
             ),
           ),
           Stream.runDrain,

package/src/materializer-helper.ts

@@ -1,8 +1,7 @@
-import { isDevEnv, isNil, isReadonlyArray } from '@livestore/utils'
-import { Hash, Option, Schema } from '@livestore/utils/effect'
+import { isDevEnv } from '@livestore/utils'
+import { Hash, Option, Predicate, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
 import type { SqliteDb } from './adapter-types.ts'
-import { SessionIdSymbol } from './adapter-types.ts'
 import type { EventDef, Materializer, MaterializerContextQuery, MaterializerResult } from './schema/EventDef/mod.ts'
 import type * as LiveStoreEvent from './schema/LiveStoreEvent/mod.ts'
 import type { LiveStoreSchema } from './schema/schema.ts'
@@ -39,9 +38,10 @@ export const getExecStatementsFromMaterializer = ({
         }
       : event.decoded
 
-  const eventArgsEncoded = isNil(event.decoded?.args) === true
-    ? undefined
-    : Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
+  const eventArgsEncoded =
+    Predicate.isNotUndefined(event.decoded) === true && Predicate.isNotNullish(event.decoded.args) === true
+      ? Schema.encodeUnknownSync(eventDef.schema)(event.decoded.args)
+      : undefined
 
   const query: MaterializerContextQuery = (
     rawQueryOrQueryBuilder:
@@ -55,7 +55,7 @@ export const getExecStatementsFromMaterializer = ({
       const { query, bindValues } = rawQueryOrQueryBuilder.asSql()
       const rawResults = dbState.select(query, prepareBindValues(bindValues, query))
       const resultSchema = getResultSchema(rawQueryOrQueryBuilder)
-      return Schema.decodeSync(resultSchema)(rawResults)
+      return Schema.decodeUnknownSync(resultSchema)(rawResults)
     } else {
       const { query, bindValues } = rawQueryOrQueryBuilder
       return dbState.select(query, prepareBindValues(bindValues, query))
@@ -126,7 +126,7 @@ const fromMaterializerResult = (
   bindValues: BindValues
   writeTables: ReadonlySet<string> | undefined
 }> => {
-  if (isReadonlyArray(materializerResult) === true) {
+  if (ReadonlyArray.isArray<MaterializerResult | ReadonlyArray<MaterializerResult>>(materializerResult) === true) {
     return materializerResult.flatMap(fromMaterializerResult)
   }
   if (isQueryBuilder(materializerResult) === true) {
@@ -144,32 +144,3 @@ const fromMaterializerResult = (
     ]
   }
 }
-
-// NOTE we should explore whether there is a more elegant solution
-// e.g. by leveraging the schema to replace the sessionIdSymbol
-export const replaceSessionIdSymbol = (
-  bindValues: Record<string, unknown> | ReadonlyArray<unknown>,
-  sessionId: string,
-) => {
-  deepReplaceValue(bindValues, SessionIdSymbol, sessionId)
-}
-
-const deepReplaceValue = <S, R>(input: any, searchValue: S, replaceValue: R): void => {
-  if (Array.isArray(input) === true) {
-    for (const i in input) {
-      if (input[i] === searchValue) {
-        input[i] = replaceValue
-      } else {
-        deepReplaceValue(input[i], searchValue, replaceValue)
-      }
-    }
-  } else if (typeof input === 'object' && input !== null) {
-    for (const key in input) {
-      if (input[key] === searchValue) {
-        input[key] = replaceValue
-      } else {
-        deepReplaceValue(input[key], searchValue, replaceValue)
-      }
-    }
-  }
-}

package/src/otel.ts

@@ -1,26 +1,25 @@
 import * as otel from '@opentelemetry/api'
 
 import { makeNoopTracer } from '@livestore/utils'
+import type { Tracer } from '@livestore/utils/effect'
 import { Effect, identity, Layer, OtelTracer } from '@livestore/utils/effect'
 
 export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend(() => {
   const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, makeNoopTracer())
 
-  const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
-    Layer.provideMerge(OtelTracerLive),
-  )
+  const TracingLive = OtelTracer.layerWithoutOtelTracer.pipe(Layer.provideMerge(OtelTracerLive))
 
   return TracingLive
 })
 
 export const provideOtel =
   ({ otelTracer, parentSpanContext }: { otelTracer?: otel.Tracer; parentSpanContext?: otel.Context }) =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, OtelTracer.OtelTracer>> => {
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, OtelTracer.OtelTracer | Tracer.Tracer>> => {
     const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, otelTracer ?? makeNoopTracer())
 
-    const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(
+    const TracingLive = OtelTracer.layerWithoutOtelTracer.pipe(
       Layer.provideMerge(OtelTracerLive),
-    ) as any as Layer.Layer<OtelTracer.OtelTracer>
+    ) as any as Layer.Layer<OtelTracer.OtelTracer | Tracer.Tracer>
 
     return effect.pipe(
       parentSpanContext !== undefined
@@ -29,11 +28,3 @@ export const provideOtel =
       Effect.provide(TracingLive),
     )
   }
-
-export const getDurationMsFromSpan = (span: otel.Span): number => {
-  const durationHr: [seconds: number, nanos: number] = (span as any)._duration
-  return durationHr[0] * 1000 + durationHr[1] / 1_000_000
-}
-
-export const getStartTimeHighResFromSpan = (span: otel.Span): DOMHighResTimeStamp =>
-  (span as any)._performanceStartTime as DOMHighResTimeStamp

package/src/rematerialize-from-eventlog.ts

@@ -1,15 +1,15 @@
 import { memoizeByRef } from '@livestore/utils'
-import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
+import { Effect, Option, ReadonlyArray as EffectArray, Schema, Stream } from '@livestore/utils/effect'
 
 import { type SqliteDb, UnknownError } from './adapter-types.ts'
 import type { MaterializeEvent } from './leader-thread/mod.ts'
 import type { EventDef, LiveStoreSchema } from './schema/mod.ts'
-import { EventSequenceNumber, LiveStoreEvent, resolveEventDef, SystemTables } from './schema/mod.ts'
+import { EventSequenceNumber, LiveStoreEvent, SystemTables } from './schema/mod.ts'
 import type { PreparedBindValues } from './util.ts'
 import { sql } from './util.ts'
 
 /** Parse JSON string to unknown value */
-const jsonParse = Schema.decodeUnknownSync(Schema.parseJson())
+const jsonParse = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown))
 
 export const rematerializeFromEventlog = Effect.fn('@livestore/common:rematerializeFromEventlog')(function* ({
   dbEventlog,
@@ -25,111 +25,114 @@ export const rematerializeFromEventlog = Effect.fn('@livestore/common:rematerial
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
   materializeEvent: MaterializeEvent
 }) {
-    const eventsCount = dbEventlog.select<{ count: number }>(
-      `SELECT COUNT(*) AS count FROM ${SystemTables.EVENTLOG_META_TABLE}`,
-    )[0]!.count
-
-    const hashEventDef = memoizeByRef((event: EventDef.AnyWithoutFn) => Schema.hash(event.schema))
-
-    const processEvent = Effect.fn(`@livestore/common:rematerializeFromEventlog:processEvent`)(function* (
-      row: SystemTables.EventlogMetaRow,
-    ) {
-      const args = jsonParse(row.argsJson)
-      const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
-        name: row.name,
-        args,
-        seqNum: {
-          global: row.seqNumGlobal,
-          client: row.seqNumClient,
-          rebaseGeneration: row.seqNumRebaseGeneration,
-        },
-        parentSeqNum: {
-          global: row.parentSeqNumGlobal,
-          client: row.parentSeqNumClient,
-          rebaseGeneration: row.parentSeqNumRebaseGeneration,
-        },
-        clientId: row.clientId,
-        sessionId: row.sessionId,
-      })
-
-      const resolution = yield* resolveEventDef(schema, {
-        operation: '@livestore/common:rematerializeFromEventlog:processEvent',
-        event: eventEncoded,
-      }).pipe(UnknownError.mapToUnknownError)
-
-      if (resolution._tag === 'unknown') {
-        // Old snapshots can contain newer events. Skip until the runtime has
-        // been updated; the event stays in the log for future replays.
-        return
-      }
+  const eventsCount = dbEventlog.select<{ count: number }>(
+    `SELECT COUNT(*) AS count FROM ${SystemTables.EVENTLOG_META_TABLE}`,
+  )[0]!.count
+
+  const hashEventDef = memoizeByRef((event: EventDef.AnyWithoutFn) => Schema.hash(event.schema))
+
+  const processEvent = Effect.fn(`@livestore/common:rematerializeFromEventlog:processEvent`)(function* (
+    row: SystemTables.EventlogMetaRow,
+  ) {
+    const args = jsonParse(row.argsJson)
+    const eventEncoded = LiveStoreEvent.Client.EncodedWithMeta.make({
+      name: row.name,
+      args,
+      seqNum: {
+        global: row.seqNumGlobal,
+        client: row.seqNumClient,
+        rebaseGeneration: row.seqNumRebaseGeneration,
+      },
+      parentSeqNum: {
+        global: row.parentSeqNumGlobal,
+        client: row.parentSeqNumClient,
+        rebaseGeneration: row.parentSeqNumRebaseGeneration,
+      },
+      clientId: row.clientId,
+      sessionId: row.sessionId,
+    })
 
-      const { eventDef } = resolution
+    const eventDef = schema.eventsDefsMap.get(row.name)
+    const materializer = schema.state.materializers.get(row.name)
 
-      if (hashEventDef(eventDef) !== row.schemaHash) {
-        yield* Effect.logWarning(
-          `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
-        )
-      }
+    if (eventDef === undefined || materializer === undefined) {
+      // Route unknown events through the normal materialization boundary so
+      // they advance the state snapshot head as no-ops.
+      yield* materializeEvent(eventEncoded, { skipEventlog: true })
+      return
+    }
 
-      // Checking whether the schema has changed in an incompatible way
-      yield* Schema.decodeUnknown(eventDef.schema)(args).pipe(
-        Effect.mapError((cause) =>
-          UnknownError.make({
-            cause,
-            note: `\
+    if (hashEventDef(eventDef) !== row.schemaHash) {
+      yield* Effect.logWarning(
+        `Schema hash mismatch for event definition ${row.name}. Trying to materialize event anyway.`,
+      )
+    }
+
+    // Checking whether the schema has changed in an incompatible way
+    yield* Schema.decodeUnknownEffect(eventDef.schema)(args).pipe(
+      Effect.mapError((cause) =>
+        UnknownError.make({
+          cause,
+          note: `\
 There was an error during rematerializing from the eventlog while decoding
 the persisted event args for event definition "${row.name}".
 This likely means the schema has changed in an incompatible way.
 `,
-          }),
-        ),
-      )
+        }),
+      ),
+    )
 
-      yield* materializeEvent(eventEncoded, { skipEventlog: true })
-    })
+    yield* materializeEvent(eventEncoded, { skipEventlog: true })
+  })
 
-    const CHUNK_SIZE = 100
+  const CHUNK_SIZE = 100
 
-    const stmt = dbEventlog.prepare(sql`\
+  const stmt = dbEventlog.prepare(sql`\
 SELECT * FROM ${SystemTables.EVENTLOG_META_TABLE} 
 WHERE seqNumGlobal > $seqNumGlobal OR (seqNumGlobal = $seqNumGlobal AND seqNumClient > $seqNumClient)
 ORDER BY seqNumGlobal ASC, seqNumClient ASC
 LIMIT ${CHUNK_SIZE}
 `)
 
-    let processedEvents = 0
-
-    yield* Stream.unfoldChunk<
-      Chunk.Chunk<SystemTables.EventlogMetaRow> | { _tag: 'Initial' },
-      SystemTables.EventlogMetaRow
-    >({ _tag: 'Initial' }, (item) => {
-      // End stream if no more rows
-      if (Chunk.isChunk(item) === true && item.length === 0) return Option.none()
-
-      const lastId = Chunk.isChunk(item) === true
-        ? Chunk.last(item).pipe(
-            Option.map((_) => ({ global: _.seqNumGlobal, client: _.seqNumClient })),
-            Option.getOrElse(() => EventSequenceNumber.Client.ROOT),
-          )
-        : EventSequenceNumber.Client.ROOT
-      const nextItem = Chunk.fromIterable(
-        stmt.select<SystemTables.EventlogMetaRow>({
-          $seqNumGlobal: lastId?.global,
-          $seqNumClient: lastId?.client,
-        } as any as PreparedBindValues),
-      )
-      const prevItem = Chunk.isChunk(item) === true ? item : Chunk.empty()
-      return Option.some([prevItem, nextItem])
-    }).pipe(
-      Stream.bufferChunks({ capacity: 2 }),
-      Stream.tap((row) =>
-        Effect.gen(function* () {
-          yield* processEvent(row)
-
-          processedEvents++
-          yield* onProgress({ done: processedEvents, total: eventsCount })
-        }),
-      ),
-      Stream.runDrain,
-    )
+  let processedEvents = 0
+
+  yield* Stream.paginate(EventSequenceNumber.Client.ROOT, (lastId) =>
+    Effect.sync(() => {
+      const rows = stmt.select<SystemTables.EventlogMetaRow>({
+        $seqNumGlobal: lastId.global,
+        $seqNumClient: lastId.client,
+      } as any as PreparedBindValues)
+
+      if (EffectArray.isReadonlyArrayNonEmpty(rows) === false) {
+        const done: readonly [
+          ReadonlyArray<SystemTables.EventlogMetaRow>,
+          Option.Option<EventSequenceNumber.Client.Composite>,
+        ] = [rows, Option.none()]
+        return done
+      }
+
+      const lastRow = EffectArray.lastNonEmpty(rows)
+      const nextCursor = EventSequenceNumber.Client.Composite.make({
+        global: lastRow.seqNumGlobal,
+        client: lastRow.seqNumClient,
+        rebaseGeneration: lastRow.seqNumRebaseGeneration,
+      })
+      const next: readonly [
+        ReadonlyArray<SystemTables.EventlogMetaRow>,
+        Option.Option<EventSequenceNumber.Client.Composite>,
+      ] = [rows, Option.some(nextCursor)]
+      return next
+    }),
+  ).pipe(
+    Stream.bufferArray({ capacity: 2 }),
+    Stream.tap((row) =>
+      Effect.gen(function* () {
+        yield* processEvent(row)
+
+        processedEvents++
+        yield* onProgress({ done: processedEvents, total: eventsCount })
+      }),
+    ),
+    Stream.runDrain,
+  )
 }, Effect.withPerformanceMeasure('@livestore/common:rematerializeFromEventlog'))

package/src/schema/EventDef/define.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from 'vitest'
+
+import { Schema } from '@livestore/utils/effect'
+
+import { synced } from './define.ts'
+
+describe('synced event wire schema', () => {
+  const occurredAt = new Date('2026-07-17T10:15:30.000Z')
+  const event = synced({
+    name: 'v1.Occurred',
+    schema: Schema.Struct({
+      occurredAt: Schema.DateFromString,
+    }),
+  })
+  const jsonSchema = Schema.fromJsonString(event.schema)
+
+  test('roundtrips a valid date through JSON', () => {
+    const encoded = Schema.encodeSync(jsonSchema)({ occurredAt })
+
+    expect(encoded).toBe('{"occurredAt":"2026-07-17T10:15:30.000Z"}')
+    expect(Schema.decodeSync(jsonSchema)(encoded)).toEqual({ occurredAt })
+  })
+
+  test('rejects invalid dates on encode and decode', () => {
+    expect(() => Schema.encodeSync(jsonSchema)({ occurredAt: new Date(Number.NaN) })).toThrow()
+    expect(() => Schema.decodeSync(jsonSchema)('{"occurredAt":"not-a-date"}')).toThrow()
+  })
+})

package/src/schema/EventDef/define.ts

@@ -29,7 +29,7 @@
  */
 
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Result, Schema } from '@livestore/utils/effect'
 
 import type { EventDef } from './event-def.ts'
 import type { EventDefFactInput, EventDefFacts } from './facts.ts'
@@ -105,15 +105,15 @@ export type DefineEventOptions<TTo, TDerived extends boolean = false> = {
 export const defineEvent = <TName extends string, TType, TEncoded = TType, TDerived extends boolean = false>(
   args: {
     name: TName
-    schema: Schema.Schema<TType, TEncoded>
+    schema: Schema.Codec<TType, TEncoded>
   } & DefineEventOptions<TType, TDerived>,
 ): EventDef<TName, TType, TEncoded, TDerived> => {
   const { name, schema, ...options } = args
 
   const makePartialEvent = (args: TType) => {
-    const res = Schema.validateEither(schema)(args)
-    if (res._tag === 'Left') {
-      shouldNeverHappen(`Invalid event args for event '${name}':`, res.left.message, '\n')
+    const res = Schema.decodeResult(Schema.toType(schema))(args)
+    if (Result.isFailure(res) === true) {
+      shouldNeverHappen(`Invalid event args for event '${name}':`, res.failure.message, '\n')
     }
     return { name: name, args }
   }
@@ -127,18 +127,19 @@ export const defineEvent = <TName extends string, TType, TEncoded = TType, TDeri
   Object.defineProperty(makePartialEvent, 'options', {
     value: {
       clientOnly: options?.clientOnly ?? false,
-      facts: options?.facts !== undefined
-        ? (args, currentFacts) => {
-            const res = options.facts!(args, currentFacts)
-            return {
-              modify: {
-                set: res.modify?.set !== undefined ? new Set(res.modify.set) : new Set(),
-                unset: res.modify?.unset !== undefined ? new Set(res.modify.unset) : new Set(),
-              },
-              require: res.require !== undefined ? new Set(res.require) : new Set(),
+      facts:
+        options?.facts !== undefined
+          ? (args, currentFacts) => {
+              const res = options.facts!(args, currentFacts)
+              return {
+                modify: {
+                  set: res.modify?.set !== undefined ? new Set(res.modify.set) : new Set(),
+                  unset: res.modify?.unset !== undefined ? new Set(res.modify.unset) : new Set(),
+                },
+                require: res.require !== undefined ? new Set(res.require) : new Set(),
+              }
             }
-          }
-        : undefined,
+          : undefined,
       derived: options?.derived ?? false,
       deprecated: options?.deprecated,
     } satisfies EventDef.Any['options'],
@@ -178,7 +179,7 @@ export const defineEvent = <TName extends string, TType, TEncoded = TType, TDeri
 export const synced = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
-    schema: Schema.Schema<TType, TEncoded>
+    schema: Schema.Codec<TType, TEncoded>
   } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: false })
 
@@ -201,7 +202,7 @@ export const synced = <TName extends string, TType, TEncoded = TType>(
  *   name: 'UiStateSet',
  *   schema: Schema.Struct({
  *     selectedTodoId: Schema.NullOr(Schema.String),
- *     filterMode: Schema.Literal('all', 'active', 'completed'),
+ *     filterMode: Schema.Literals(['all', 'active', 'completed']),
  *   }),
  * })
  *
@@ -212,6 +213,6 @@ export const synced = <TName extends string, TType, TEncoded = TType>(
 export const clientOnly = <TName extends string, TType, TEncoded = TType>(
   args: {
     name: TName
-    schema: Schema.Schema<TType, TEncoded>
+    schema: Schema.Codec<TType, TEncoded>
   } & Omit<DefineEventOptions<TType>, 'derived' | 'clientOnly'>,
 ): EventDef<TName, TType, TEncoded> => defineEvent({ ...args, clientOnly: true })

package/src/schema/EventDef/deprecated.test.ts

@@ -60,14 +60,7 @@ describe('logDeprecationWarnings', () => {
 
   const run = (effect: Effect.Effect<void>) =>
     Effect.runSync(
-      effect.pipe(
-        Effect.provide(
-          Logger.replace(
-            Logger.defaultLogger,
-            Logger.make(({ message }) => logs.push(message as unknown[])),
-          ),
-        ),
-      ),
+      effect.pipe(Effect.provide(Logger.layer([Logger.make(({ message }) => logs.push(message as unknown[]))]))),
     )
 
   test('logs event deprecation warning', () => {

package/src/schema/EventDef/deprecated.ts

@@ -30,20 +30,19 @@
  * @module
  */
 
-import type { Schema } from '@livestore/utils/effect'
-import { Effect, Option, SchemaAST } from '@livestore/utils/effect'
+import { type Schema, Effect, Option, SchemaAST } from '@livestore/utils/effect'
 
 import type { EventDef } from './event-def.ts'
 
-/** Symbol used to mark schemas as deprecated. */
-export const DeprecatedId = Symbol.for('livestore/schema/annotations/deprecated')
+/** Annotation key used to mark schemas as deprecated. */
+export const DeprecatedId = 'livestore/schema/annotations/deprecated'
 
 /**
  * Marks a schema field as deprecated with a reason message.
  * When an event is committed with a deprecated field that has a value,
  * a warning will be logged.
  *
- * Works with both Schema types and PropertySignatures (from Schema.optional).
+ * Works with Schema fields, including optional fields from Schema.optional.
  *
  * @param reason - Explanation of why this field is deprecated and what to use instead
  * @returns A function that adds the deprecation annotation to the schema
@@ -58,8 +57,8 @@ export const DeprecatedId = Symbol.for('livestore/schema/annotations/deprecated'
  */
 export const deprecated =
   (reason: string) =>
-  <T extends { annotations: (annotations: { readonly [DeprecatedId]?: string }) => T }>(schema: T): T =>
-    schema.annotations({ [DeprecatedId]: reason })
+  <T extends Schema.Top>(schema: T): T['Rebuild'] =>
+    schema.annotate({ [DeprecatedId]: reason })
 
 /**
  * Checks if a schema has a deprecation annotation.
@@ -67,8 +66,8 @@ export const deprecated =
  * @param schema - The schema to check
  * @returns The deprecation reason if deprecated, None otherwise
  */
-export const getDeprecatedReason = <A, I, R>(schema: Schema.Schema<A, I, R>): Option.Option<string> =>
-  SchemaAST.getAnnotation<string>(DeprecatedId)(schema.ast)
+export const getDeprecatedReason = (schema: Schema.Top): Option.Option<string> =>
+  Option.fromUndefinedOr(SchemaAST.resolveAt<string>(DeprecatedId)(schema.ast))
 
 /**
  * Checks if a schema is deprecated.
@@ -76,8 +75,7 @@ export const getDeprecatedReason = <A, I, R>(schema: Schema.Schema<A, I, R>): Op
  * @param schema - The schema to check
  * @returns true if the schema is deprecated
  */
-export const isDeprecated = <A, I, R>(schema: Schema.Schema<A, I, R>): boolean =>
-  Option.isSome(getDeprecatedReason(schema))
+export const isDeprecated = (schema: Schema.Top): boolean => Option.isSome(getDeprecatedReason(schema))
 
 /**
  * Finds deprecated fields with values in the given event arguments.
@@ -88,28 +86,27 @@ export const isDeprecated = <A, I, R>(schema: Schema.Schema<A, I, R>): boolean =
  * @returns Array of objects containing field name and deprecation reason
  */
 export const findDeprecatedFieldsWithValues = (
-  schema: Schema.Schema.All,
+  schema: Schema.Top,
   args: Record<string, unknown>,
 ): Array<{ field: string; reason: string }> => {
   const result: Array<{ field: string; reason: string }> = []
-  const ast = schema.ast
+  const ast = SchemaAST.toType(schema.ast)
 
-  // Handle TypeLiteral (Struct) schemas
-  if (ast._tag === 'TypeLiteral') {
+  // Handle Objects (Struct) schemas
+  if (SchemaAST.isObjects(ast) === true) {
     for (const prop of ast.propertySignatures) {
       const fieldName = String(prop.name)
       const fieldValue = args[fieldName]
 
       // Only check fields that have a value (not undefined)
       if (fieldValue !== undefined) {
-        // Check deprecation on the property signature itself (for Schema.optional(...).pipe(deprecated(...)))
-        const propAnnotations = prop.annotations as Record<symbol, unknown> | undefined
-        const deprecationReason = propAnnotations?.[DeprecatedId] as string | undefined
+        // Check deprecation on the property key itself (for Schema.optional(...).pipe(deprecated(...)))
+        const deprecationReason = prop.type.context?.annotations?.[DeprecatedId] as string | undefined
 
         // Also check deprecation on the type (for direct field deprecation)
-        const typeDeprecation = SchemaAST.getAnnotation<string>(DeprecatedId)(prop.type)
+        const typeDeprecation = SchemaAST.resolveAt<string>(DeprecatedId)(prop.type)
 
-        const reason = deprecationReason ?? (Option.isSome(typeDeprecation) === true ? typeDeprecation.value : undefined)
+        const reason = deprecationReason ?? typeDeprecation
         if (reason !== undefined) {
           result.push({ field: fieldName, reason })
         }

package/src/schema/EventDef/event-def.ts

@@ -34,7 +34,7 @@ export type EventDef<TName extends string, TType, TEncoded = TType, TDerived ext
   name: TName
 
   /** Effect Schema used for validating and encoding/decoding event arguments. */
-  schema: Schema.Schema<TType, TEncoded>
+  schema: Schema.Codec<TType, TEncoded>
 
   options: {
     /**
@@ -62,9 +62,7 @@ export type EventDef<TName extends string, TType, TEncoded = TType, TDerived ext
    * Callable signature - creates a partial event with decoded arguments.
    * The returned object can be passed directly to `store.commit()`.
    */
-  (
-    args: TType,
-  ): {
+  (args: TType): {
     name: TName
     args: TType
   }