effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/observability/Otlp.ts

@@ -28,13 +28,13 @@ export const layer = (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> => {
   const base = HttpClientRequest.get(options.baseUrl)
   const url = (path: string) => HttpClientRequest.appendUrl(base, path).url
@@ -83,13 +83,13 @@ export const layerJson: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerJson))
 
 /**
@@ -106,11 +106,11 @@ export const layerProtobuf: (options: {
   readonly headers?: Headers.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly loggerExportInterval?: Duration.DurationInput | undefined
+  readonly loggerExportInterval?: Duration.Input | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-  readonly metricsExportInterval?: Duration.DurationInput | undefined
+  readonly metricsExportInterval?: Duration.Input | undefined
   readonly metricsTemporality?: AggregationTemporality | undefined
-  readonly tracerExportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly tracerExportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerProtobuf))

package/src/unstable/observability/OtlpExporter.ts

@@ -2,14 +2,14 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
 import * as Num from "../../Number.ts"
+import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Headers from "../../unstable/http/Headers.ts"
 import * as HttpClient from "../../unstable/http/HttpClient.ts"
 import * as HttpClientError from "../../unstable/http/HttpClientError.ts"
@@ -24,7 +24,10 @@ const policy = Schedule.forever.pipe(
       && error.reason._tag === "StatusCodeError"
       && error.reason.response.status === 429
     ) {
-      const retryAfter = UndefinedOr.map(error.reason.response.headers["retry-after"], Num.parse) ?? 5
+      const retryAfter = Option.fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(
+        Option.flatMap(Num.parse),
+        Option.getOrElse(() => 5)
+      )
       return Effect.succeed(Duration.seconds(retryAfter))
     }
     return Effect.succeed(Duration.seconds(1))
@@ -40,24 +43,25 @@ export const make: (
     readonly url: string
     readonly headers: Headers.Input | undefined
     readonly label: string
-    readonly exportInterval: Duration.DurationInput
+    readonly exportInterval: Duration.Input
     readonly maxBatchSize: number | "disabled"
     readonly body: (data: Array<any>) => HttpBody
-    readonly shutdownTimeout: Duration.DurationInput
+    readonly shutdownTimeout: Duration.Input
   }
 ) => Effect.Effect<
   { readonly push: (data: unknown) => void },
   never,
   HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
-  const services = yield* Effect.services<Scope.Scope | HttpClient.HttpClient>()
-  const clock = ServiceMap.get(services, Clock)
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Scope.Scope | HttpClient.HttpClient>()
+  const clock = Context.get(services, Clock)
+  const scope = Context.get(services, Scope.Scope)
   const runFork = Effect.runForkWith(services)
-  const exportInterval = Duration.max(Duration.fromDurationInputUnsafe(options.exportInterval), Duration.zero)
+  const exportInterval = Duration.max(Duration.fromInputUnsafe(options.exportInterval), Duration.zero)
   let disabledUntil: number | undefined = undefined
 
-  const client = HttpClient.filterStatusOk(ServiceMap.get(services, HttpClient.HttpClient)).pipe(
+  const client = HttpClient.filterStatusOk(Context.get(services, HttpClient.HttpClient)).pipe(
+    HttpClient.transformResponse(Effect.provideService(HttpClient.TracerPropagationEnabled, false)),
     HttpClient.retryTransient({ schedule: policy, times: 3 })
   )
 

package/src/unstable/observability/OtlpLogger.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
+import { Clock } from "../../Clock.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Layer from "../../Layer.ts"
@@ -30,9 +31,9 @@ export const make: (
       readonly attributes?: Record<string, unknown>
     } | undefined
     readonly headers?: Headers.Input | undefined
-    readonly exportInterval?: Duration.DurationInput | undefined
+    readonly exportInterval?: Duration.Input | undefined
     readonly maxBatchSize?: number | undefined
-    readonly shutdownTimeout?: Duration.DurationInput | undefined
+    readonly shutdownTimeout?: Duration.Input | undefined
     readonly excludeLogSpans?: boolean | undefined
   }
 ) => Effect.Effect<
@@ -66,7 +67,8 @@ export const make: (
   })
 
   const opts = {
-    excludeLogSpans: options.excludeLogSpans ?? false
+    excludeLogSpans: options.excludeLogSpans ?? false,
+    clock: yield* Clock
   }
   return Logger.make((options) => {
     exporter.push(makeLogRecord(options, opts))
@@ -85,9 +87,9 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
   readonly maxBatchSize?: number | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly excludeLogSpans?: boolean | undefined
   readonly mergeWithExisting?: boolean | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
@@ -104,11 +106,13 @@ export interface LogsData {
 
 // internal
 
-const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
+const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
+  readonly clock: Clock
 }): ILogRecord => {
-  const now = options.date.getTime()
-  const nanosString = `${now}000000`
+  const now = opts.clock.currentTimeNanosUnsafe()
+  const nanosString = now.toString()
+  const nowMillis = options.date.getTime()
 
   const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
   attributes.push({
@@ -119,7 +123,7 @@ const makeLogRecord = (options: Logger.Logger.Options<unknown>, opts: {
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
       attributes.push({
         key: `logSpan.${label}`,
-        value: { stringValue: `${now - startTime}ms` }
+        value: { stringValue: `${nowMillis - startTime}ms` }
       })
     }
   }

package/src/unstable/observability/OtlpMetrics.ts

@@ -60,8 +60,8 @@ export const make: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
 }) => Effect.Effect<
   void,
@@ -79,7 +79,7 @@ export const make: (options: {
     name: OtlpResource.serviceNameUnsafe(resource)
   }
 
-  const services = yield* Effect.services<never>()
+  const services = yield* Effect.context<never>()
 
   // State for delta temporality tracking
   let previousExportTimeNanos: bigint = startTimeNanos
@@ -124,7 +124,7 @@ export const make: (options: {
               if (typeof currentCount === "bigint" && typeof previousCount === "bigint") {
                 reportValue = currentCount - previousCount
                 // Handle reset: if current < previous, report current value
-                if (reportValue < 0n) {
+                if (reportValue < BigInt(0)) {
                   reportValue = currentCount
                 }
               } else {
@@ -440,8 +440,8 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> => Layer.effectDiscard(make(options))
 

package/src/unstable/observability/OtlpSerialization.ts

@@ -1,8 +1,8 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpBody from "../http/HttpBody.ts"
 import * as otlpProtobuf from "./internal/otlpProtobuf.ts"
 import type { LogsData } from "./OtlpLogger.ts"
@@ -13,7 +13,7 @@ import type { TraceData } from "./OtlpTracer.ts"
  * @since 4.0.0
  * @category Services
  */
-export class OtlpSerialization extends ServiceMap.Service<OtlpSerialization, {
+export class OtlpSerialization extends Context.Service<OtlpSerialization, {
   readonly traces: (data: TraceData) => HttpBody.HttpBody
   readonly metrics: (data: MetricsData) => HttpBody.HttpBody
   readonly logs: (data: LogsData) => HttpBody.HttpBody

package/src/unstable/observability/OtlpTracer.ts

@@ -2,13 +2,14 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import type * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { ExtractTag, Mutable } from "../../Types.ts"
 import type * as Headers from "../http/Headers.ts"
@@ -32,10 +33,10 @@ export const make: (
       readonly attributes?: Record<string, unknown>
     } | undefined
     readonly headers?: Headers.Input | undefined
-    readonly exportInterval?: Duration.DurationInput | undefined
+    readonly exportInterval?: Duration.Input | undefined
     readonly maxBatchSize?: number | undefined
     readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-    readonly shutdownTimeout?: Duration.DurationInput | undefined
+    readonly shutdownTimeout?: Duration.Input | undefined
   }
 ) => Effect.Effect<
   Tracer.Tracer,
@@ -109,10 +110,10 @@ export const layer: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-  readonly exportInterval?: Duration.DurationInput | undefined
+  readonly exportInterval?: Duration.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-  readonly shutdownTimeout?: Duration.DurationInput | undefined
+  readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, OtlpSerialization | HttpClient.HttpClient> = flow(make, Layer.effect(Tracer.Tracer))
 
 // internal
@@ -150,8 +151,8 @@ type RemainingSpanImpl = Omit<Tracer.Span, (keyof typeof SpanProto) | "traceId"
 
 const makeSpan = (options: {
   readonly name: string
-  readonly parent: Tracer.AnySpan | undefined
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly parent: Option.Option<Tracer.AnySpan>
+  readonly annotations: Context.Context<never>
   readonly status: Tracer.SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
   readonly links: ReadonlyArray<Tracer.SpanLink>
@@ -163,8 +164,8 @@ const makeSpan = (options: {
     Object.create(SpanProto),
     options satisfies RemainingSpanImpl
   )
-  if (self.parent) {
-    self.traceId = self.parent.traceId
+  if (Option.isSome(self.parent)) {
+    self.traceId = self.parent.value.traceId
   } else {
     self.traceId = generateId(32)
   }
@@ -249,7 +250,10 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   return {
     traceId: self.traceId,
     spanId: self.spanId,
-    parentSpanId: self.parent ? self.parent.spanId : undefined,
+    parentSpanId: Option.match(self.parent, {
+      onNone: () => undefined,
+      onSome: (parent) => parent.spanId
+    }),
     name: self.name,
     kind: SpanKind[self.kind],
     startTimeUnixNano: String(status.startTime),

package/src/unstable/observability/PrometheusMetrics.ts

@@ -27,10 +27,10 @@
  *
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 
@@ -114,7 +114,7 @@ export interface HttpOptions extends FormatOptions {
  */
 export const format: (options?: FormatOptions | undefined) => Effect.Effect<string> = Effect.fnUntraced(
   function*(options) {
-    const services = yield* Effect.services<never>()
+    const services = yield* Effect.context<never>()
     return formatUnsafe(services, options)
   }
 )
@@ -122,17 +122,17 @@ export const format: (options?: FormatOptions | undefined) => Effect.Effect<stri
 /**
  * Synchronously format all metrics in the registry to Prometheus exposition format.
  *
- * This is a low-level function that requires access to the service map.
+ * This is a low-level function that requires access to the context.
  * Most users should use `format` instead.
  *
  * @since 4.0.0
  * @category Formatting
  */
 export const formatUnsafe = (
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   options?: FormatOptions | undefined
 ): string => {
-  const snapshot = Metric.snapshotUnsafe(services)
+  const snapshot = Metric.snapshotUnsafe(context)
   const prefix = options?.prefix ? sanitizeMetricName(options.prefix) + "_" : ""
   const mapper = options?.metricNameMapper ?? ((name: string) => name)
   const lines: Array<string> = []

package/src/unstable/observability/internal/protobuf.ts

@@ -29,9 +29,9 @@ const encodeTag = (fieldNumber: number, wireType: WireType): number => (fieldNum
 export const encodeVarint = (value: number | bigint): Uint8Array => {
   const bytes: Array<number> = []
   let n = typeof value === "bigint" ? value : BigInt(value)
-  while (n > 0x7fn) {
-    bytes.push(Number(n & 0x7fn) | 0x80)
-    n >>= 7n
+  while (n > BigInt(127)) {
+    bytes.push(Number(n & BigInt(127)) | 0x80)
+    n >>= BigInt(7)
   }
   bytes.push(Number(n))
   return new Uint8Array(bytes)
@@ -44,7 +44,7 @@ export const encodeVarint = (value: number | bigint): Uint8Array => {
  */
 export const encodeSint = (value: number | bigint): Uint8Array => {
   const n = typeof value === "bigint" ? value : BigInt(value)
-  const zigzag = (n << 1n) ^ (n >> 63n)
+  const zigzag = (n << BigInt(1)) ^ (n >> BigInt(63))
   return encodeVarint(zigzag)
 }
 

package/src/unstable/persistence/KeyValueStore.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Encoding from "../../Encoding.ts"
@@ -13,8 +14,9 @@ import type { PlatformError } from "../../PlatformError.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
+import * as SqlClient from "../sql/SqlClient.ts"
+import type { SqlError } from "../sql/SqlError.ts"
 
 const TypeId = "~effect/persistence/KeyValueStore" as const
 
@@ -170,10 +172,10 @@ export class KeyValueStoreError extends Data.TaggedError("KeyValueStoreError")<{
  * @since 4.0.0
  * @category tags
  */
-export const KeyValueStore: ServiceMap.Service<
+export const KeyValueStore: Context.Service<
   KeyValueStore,
   KeyValueStore
-> = ServiceMap.Service("effect/persistence/KeyValueStore")
+> = Context.Service("effect/persistence/KeyValueStore")
 
 /**
  * @since 4.0.0
@@ -391,6 +393,227 @@ export const layerFileSystem = (
     })
   }))
 
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export interface LayerSqlOptions {
+  /**
+   * The SQL table name used to store values.
+   *
+   * @default "effect_key_value_store"
+   */
+  readonly table?: string
+}
+
+/**
+ * @since 4.0.0
+ * @category layers
+ */
+export const layerSql = (
+  options: LayerSqlOptions = {}
+): Layer.Layer<KeyValueStore, never, SqlClient.SqlClient> =>
+  Layer.effect(KeyValueStore)(
+    Effect.gen(function*() {
+      const sql = (yield* SqlClient.SqlClient).withoutTransforms()
+      const table = sql(options.table ?? "effect_key_value_store")
+
+      yield* sql.onDialectOrElse({
+        mysql: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id VARCHAR(191) PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        pg: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BYTEA NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        mssql: () =>
+          sql`
+          IF NOT EXISTS (SELECT * FROM sysobjects WHERE name=${table} AND xtype='U')
+          CREATE TABLE ${table} (
+            id NVARCHAR(450) PRIMARY KEY,
+            value VARBINARY(MAX) NOT NULL,
+            value_type SMALLINT NOT NULL
+          )
+        `,
+        // sqlite
+        orElse: () =>
+          sql`
+          CREATE TABLE IF NOT EXISTS ${table} (
+            id TEXT PRIMARY KEY,
+            value BLOB NOT NULL,
+            value_type INTEGER NOT NULL
+          )
+        `
+      }).pipe(Effect.orDie)
+
+      type UpsertFn = (entry: {
+        id: string
+        value: Uint8Array
+        value_type: number
+      }) => Effect.Effect<unknown, SqlError>
+
+      const upsert = sql.onDialectOrElse({
+        pg: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT (id) DO UPDATE SET value=EXCLUDED.value, value_type=EXCLUDED.value_type
+        `.unprepared,
+        mysql: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON DUPLICATE KEY UPDATE value=VALUES(value), value_type=VALUES(value_type)
+        `,
+        mssql: (): UpsertFn => (entry) =>
+          sql`
+          MERGE ${table} AS target
+          USING (SELECT ${entry.id} AS id, ${entry.value} AS value, ${entry.value_type} AS value_type) AS source
+          ON target.id = source.id
+          WHEN MATCHED THEN UPDATE SET value = source.value, value_type = source.value_type
+          WHEN NOT MATCHED THEN INSERT (id, value, value_type)
+          VALUES (source.id, source.value, source.value_type);
+        `,
+        // sqlite
+        orElse: (): UpsertFn => (entry) =>
+          sql`
+          INSERT INTO ${table} (id, value, value_type) VALUES (${entry.id}, ${entry.value}, ${entry.value_type})
+          ON CONFLICT(id) DO UPDATE SET value=excluded.value, value_type=excluded.value_type
+        `.unprepared
+      })
+
+      const encoder = new TextEncoder()
+      const decoder = new TextDecoder()
+      const ValueTypeString = 0
+      const ValueTypeUint8Array = 1
+
+      type Row = {
+        value: Uint8Array
+        value_type: number
+      }
+
+      return make({
+        get: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "get",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(decoder.decode(row.value))
+                case ValueTypeUint8Array:
+                  return Effect.succeed(Encoding.encodeBase64(row.value))
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "get",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        getUint8Array: (key: string) =>
+          sql<Row>`SELECT value, value_type FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "getUint8Array",
+                key,
+                message: `Unable to get item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.flatMap((rows) => {
+              if (rows.length === 0) {
+                return Effect.undefined
+              }
+              const row = rows[0]
+              switch (row.value_type) {
+                case ValueTypeString:
+                  return Effect.succeed(row.value)
+                case ValueTypeUint8Array:
+                  return Effect.succeed(row.value)
+                default:
+                  return Effect.fail(
+                    new KeyValueStoreError({
+                      method: "getUint8Array",
+                      key,
+                      message: `Invalid stored value type for key ${key}: ${row.value_type}`
+                    })
+                  )
+              }
+            })
+          ),
+        set: (key: string, value: string | Uint8Array) =>
+          upsert({
+            id: key,
+            value: typeof value === "string" ? encoder.encode(value) : value,
+            value_type: typeof value === "string" ? ValueTypeString : ValueTypeUint8Array
+          }).pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "set",
+                key,
+                message: `Unable to set item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        remove: (key: string) =>
+          sql`DELETE FROM ${table} WHERE id = ${key}`.pipe(
+            Effect.mapError((cause) =>
+              new KeyValueStoreError({
+                method: "remove",
+                key,
+                message: `Unable to remove item with key ${key}`,
+                cause
+              })
+            ),
+            Effect.asVoid
+          ),
+        clear: sql`DELETE FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "clear",
+              message: `Unable to clear storage`,
+              cause
+            })
+          ),
+          Effect.asVoid
+        ),
+        size: sql<{ count: number }>`SELECT COUNT(*) as count FROM ${table}`.pipe(
+          Effect.mapError((cause) =>
+            new KeyValueStoreError({
+              method: "size",
+              message: `Unable to get size`,
+              cause
+            })
+          ),
+          Effect.map((rows) => rows.length === 0 ? 0 : Number(rows[0].count))
+        )
+      })
+    })
+  )
+
 const SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore" as const
 
 /**

package/src/unstable/persistence/Persistable.ts

@@ -1,7 +1,7 @@
 /**
  * @since 4.0.0
  */
-import type { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
@@ -87,7 +87,7 @@ export type Services<A extends Any> =
  * @since 4.0.0
  * @category Models
  */
-export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => DurationInput
+export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => Duration.Input
 
 /**
  * @since 4.0.0
@@ -194,5 +194,5 @@ export const deserializeExit = <A extends Schema.Top, E extends Schema.Top>(
   A["DecodingServices"] | E["DecodingServices"]
 > => {
   const schema = Schema.toCodecJson(exitSchema(self))
-  return Schema.decodeEffect(schema)(encoded)
+  return Schema.decodeUnknownEffect(schema)(encoded)
 }