effect 4.0.0-beta.100 → 4.0.0-beta.102

package/src/unstable/http/UrlParams.ts

@@ -16,6 +16,7 @@ import { dual } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import type { Inspectable } from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import * as Option from "../../Option.ts"
 import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
@@ -236,15 +237,15 @@ export interface UrlParamsSchema extends Schema.declare<UrlParams, ReadonlyArray
 export const UrlParamsSchema: UrlParamsSchema = Schema.declare(
   isUrlParams,
   {
-    typeConstructor: {
-      _tag: "effect/http/UrlParams"
-    },
-    generation: {
-      runtime: `UrlParams.UrlParamsSchema`,
-      Type: `UrlParams.UrlParams`,
-      Encoded: `typeof UrlParams.UrlParamsSchema["Encoded"]`,
-      importDeclaration: `import * as UrlParams from "effect/unstable/http/UrlParams"`
+    representation: {
+      id: "effect/http/UrlParams",
+      payload: null
     },
+    toCode: () => ({
+      runtime: "UrlParams.UrlParamsSchema",
+      Type: "UrlParams.UrlParams",
+      importDeclarations: [`import * as UrlParams from "effect/unstable/http/UrlParams"`]
+    }),
     expected: "UrlParams",
     toEquivalence: () => Equivalence,
     toCodec: () =>
@@ -675,13 +676,15 @@ export const toString = (input: Input): string => new URLSearchParams(fromInput(
 export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyArray<string>> => {
   const out: Record<string, string | Arr.NonEmptyArray<string>> = {}
   for (const [k, value] of self.params) {
-    const curr = out[k]
-    if (curr === undefined) {
-      out[k] = value
-    } else if (typeof curr === "string") {
-      out[k] = [curr, value]
+    if (!Object.hasOwn(out, k)) {
+      InternalRecord.assignProperty(out, k, value)
     } else {
-      curr.push(value)
+      const current = out[k]
+      if (typeof current === "string") {
+        InternalRecord.assignProperty(out, k, [current, value])
+      } else {
+        current.push(value)
+      }
     }
   }
   return out

package/src/unstable/httpapi/HttpApi.ts

@@ -145,7 +145,7 @@ const Proto = {
   ) {
     const groups = { ...this.groups }
     for (const group of toAdd) {
-      InternalRecord.set(groups, group.identifier, group)
+      InternalRecord.assignProperty(groups, group.identifier, group)
     }
     return makeProto({
       ...optionsFromApi(this),
@@ -157,9 +157,9 @@ const Proto = {
     api: Top
   ) {
     const newGroups = { ...this.groups }
-    for (const key in api.groups) {
+    for (const key of Object.keys(api.groups)) {
       const group = api.groups[key]
-      InternalRecord.set(
+      InternalRecord.assignProperty(
         newGroups,
         key,
         group.annotateMerge(Context.merge(api.annotations, group.annotations))

package/src/unstable/httpapi/HttpApiClient.ts

@@ -520,10 +520,10 @@ export const makeWith = <ApiId extends string, Groups extends HttpApiGroup.Const
     ...options,
     onGroup({ group }) {
       if (group.topLevel) return
-      InternalRecord.set(client, group.identifier, {})
+      InternalRecord.assignProperty(client, group.identifier, {})
     },
     onEndpoint({ endpoint, endpointFn, group }) {
-      InternalRecord.set(
+      InternalRecord.assignProperty(
         group.topLevel ? client : client[group.identifier],
         endpoint.identifier,
         endpointFn
@@ -565,7 +565,7 @@ export const group = <
     ...options,
     predicate: ({ group }) => group.identifier === options.group,
     onEndpoint({ endpoint, endpointFn }) {
-      InternalRecord.set(client, endpoint.identifier, endpointFn)
+      InternalRecord.assignProperty(client, endpoint.identifier, endpointFn)
     }
   }).pipe(Effect.map(() => client)) as any
 }
@@ -662,7 +662,7 @@ export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
   HttpApi.reflect(api as unknown as HttpApi.Top, {
     onGroup({ group }) {
       if (group.topLevel) return
-      InternalRecord.set(builder, group.identifier, {})
+      InternalRecord.assignProperty(builder, group.identifier, {})
     },
     onEndpoint({ group, endpoint }) {
       const makeUrl = compilePath(endpoint.path)
@@ -688,7 +688,7 @@ export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
         const url = query === "" ? path : `${path}?${query}`
         return options?.baseUrl === undefined ? url : new URL(url, options.baseUrl.toString()).toString()
       }
-      InternalRecord.set(
+      InternalRecord.assignProperty(
         group.topLevel ? builder : builder[group.identifier],
         endpoint.identifier,
         endpointBuilder

package/src/unstable/httpapi/HttpApiGroup.ts

@@ -308,7 +308,7 @@ const Proto = {
   add(this: Top, ...toAdd: NonEmptyReadonlyArray<HttpApiEndpoint.Top>) {
     const endpoints = { ...this.endpoints }
     for (const endpoint of toAdd) {
-      InternalRecord.set(endpoints, endpoint.identifier, endpoint)
+      InternalRecord.assignProperty(endpoints, endpoint.identifier, endpoint)
     }
     return makeProto({
       ...optionsFromGroup(this),

package/src/unstable/httpapi/OpenApi.ts

@@ -14,13 +14,14 @@ import * as Context from "../../Context.ts"
 import * as Equal from "../../Equal.ts"
 import { constFalse } from "../../Function.ts"
 import * as InternalRecord from "../../internal/record.ts"
+import * as InternalToJsonSchemaDocument from "../../internal/schema/toJsonSchemaDocument.ts"
+import * as InternalToRepresentation from "../../internal/schema/toRepresentation.ts"
 import * as JsonPatch from "../../JsonPatch.ts"
 import { escapeToken } from "../../JsonPointer.ts"
 import * as JsonSchema from "../../JsonSchema.ts"
 import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as SchemaAST from "../../SchemaAST.ts"
-import * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
 import * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
@@ -212,6 +213,17 @@ export const annotations: (
 
 const apiCache = new WeakMap<HttpApi.Constraint, OpenAPISpec>()
 
+type CompileSchemas = (
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
+) => JsonSchema.MultiDocument<"openapi-3.1">
+
+const compileSchemas: CompileSchemas = (asts) =>
+  JsonSchema.toMultiDocumentOpenApi3_1(
+    InternalToJsonSchemaDocument.toJsonSchemaMultiDocument(
+      InternalToRepresentation.toRepresentations(Arr.map(asts, Schema.toCodecJsonAST))
+    )
+  )
+
 /**
  * This function checks if a given tag exists within the provided context. If
  * the tag is present, it retrieves the associated value and applies the given
@@ -251,7 +263,15 @@ function processAnnotation<Services, S, I>(
 export function fromApi<Id extends string, Groups extends HttpApiGroup.Constraint>(
   api: HttpApi.HttpApi<Id, Groups>
 ): OpenAPISpec {
-  const cached = apiCache.get(api)
+  return fromApiWith(api, apiCache, compileSchemas)
+}
+
+function fromApiWith<Id extends string, Groups extends HttpApiGroup.Constraint>(
+  api: HttpApi.HttpApi<Id, Groups>,
+  cache: WeakMap<HttpApi.Constraint, OpenAPISpec>,
+  compileSchemas: CompileSchemas
+): OpenAPISpec {
+  const cached = cache.get(api)
   if (cached !== undefined) {
     return cached
   }
@@ -318,7 +338,10 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
         tag.externalDocs = externalDocs
       })
       processAnnotation(group.annotations, Override, (override) => {
-        Object.assign(tag, override)
+        // OpenAPI documents are JSON, so symbol keys are intentionally ignored.
+        for (const [key, value] of Object.entries(override)) {
+          InternalRecord.assignProperty(tag as any, key, value)
+        }
       })
       processAnnotation(group.annotations, Transform, (transformFn) => {
         tag = transformFn(tag) as OpenAPISpecTag
@@ -348,9 +371,9 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
       function processResponseBodies(bodies: ResponseBodies, defaultDescription: () => string) {
         for (const [status, { content, descriptions, streamContent }] of bodies) {
           const description = descriptions.size > 0 ? Array.from(descriptions).join(" | ") : defaultDescription()
-          op.responses[status] = {
+          InternalRecord.assignProperty(op.responses, status, {
             description
-          }
+          })
           if (content !== undefined) {
             content.forEach((map, encoding) => {
               map.forEach((schemas, contentType) => {
@@ -363,9 +386,9 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
                   path: ["paths", path, method, "responses", String(status), "content", contentType, "schema"]
                 })
                 op.responses[status].content ??= {}
-                op.responses[status].content[contentType] = {
+                InternalRecord.assignProperty(op.responses[status].content, contentType, {
                   schema: {}
-                }
+                })
               })
             })
           }
@@ -408,7 +431,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
                     "errorSchema"
                   ]
                 })
-                op.responses[status].content[contentType] = {
+                InternalRecord.assignProperty(op.responses[status].content, contentType, {
                   schema: {},
                   "x-effect-stream": {
                     encoding: "sse",
@@ -416,9 +439,9 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
                     errorSchema: {},
                     failureEvent: reservedStreamFailureEvent
                   }
-                }
+                })
               } else {
-                op.responses[status].content[contentType] = {
+                InternalRecord.assignProperty(op.responses[status].content, contentType, {
                   schema: {
                     type: "string",
                     format: "binary"
@@ -426,7 +449,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
                   "x-effect-stream": {
                     encoding: "uint8array"
                   }
-                }
+                })
               }
             })
           }
@@ -483,7 +506,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
       ) {
         const scheme = makeSecurityScheme(security)
         if (!Object.hasOwn(spec.components.securitySchemes, name)) {
-          InternalRecord.set(spec.components.securitySchemes, name, scheme)
+          InternalRecord.assignProperty(spec.components.securitySchemes, name, scheme)
           return
         }
         if (
@@ -522,9 +545,9 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
               ast: toEncodingAST(ast, encoding._tag),
               path: ["paths", path, method, "requestBody", "content", contentType, "schema"]
             })
-            content[contentType] = {
+            InternalRecord.assignProperty(content, contentType, {
               schema: {}
-            }
+            })
           }
           op.requestBody = { content, required: true }
         }
@@ -552,7 +575,10 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
       )
 
       processAnnotation(endpoint.annotations, Override, (override) => {
-        Object.assign(op, override)
+        // OpenAPI documents are JSON, so symbol keys are intentionally ignored.
+        for (const [key, value] of Object.entries(override)) {
+          InternalRecord.assignProperty(op as any, key, value)
+        }
       })
       processAnnotation(endpoint.annotations, Transform, (transformFn) => {
         op = transformFn(op) as OpenAPISpecOperation
@@ -570,8 +596,8 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
         operationIds.add(operationId)
       }
       pathOperations.add(pathOperation)
-      if (!spec.paths[path]) {
-        spec.paths[path] = {}
+      if (!Object.hasOwn(spec.paths, path)) {
+        InternalRecord.assignProperty(spec.paths, path, {})
       }
       spec.paths[path][method] = op
     }
@@ -581,10 +607,10 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
     componentSchemas.forEach((componentSchema) => {
       const identifier = SchemaAST.resolveIdentifier(componentSchema.ast)
       if (identifier !== undefined) {
-        if (identifier in spec.components.schemas) {
+        if (Object.hasOwn(spec.components.schemas, identifier)) {
           throw new globalThis.Error(`Duplicate component schema identifier: ${identifier}`)
         }
-        spec.components.schemas[identifier] = {}
+        InternalRecord.assignProperty(spec.components.schemas, identifier, {})
         pathOps.push({
           _tag: "schema",
           ast: componentSchema.ast,
@@ -599,12 +625,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
   }
 
   if (Arr.isArrayNonEmpty(pathOps)) {
-    const multiDocument = SchemaRepresentation.fromASTs(
-      Arr.map(pathOps, (op) => op.ast)
-    )
-    const jsonSchemaMultiDocument = JsonSchema.toMultiDocumentOpenApi3_1(
-      SchemaRepresentation.toJsonSchemaMultiDocument(multiDocument)
-    )
+    const jsonSchemaMultiDocument = compileSchemas(Arr.map(pathOps, (op) => op.ast))
     const patchOps: Array<JsonPatch.JsonPatchOperation> = pathOps.map((op, i) => {
       const oppath = escapePath(op.path)
       const value = jsonSchemaMultiDocument.schemas[i]
@@ -633,13 +654,16 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Constrain
   })
 
   processAnnotation(api.annotations, Override, (override) => {
-    Object.assign(spec, override)
+    // OpenAPI documents are JSON, so symbol keys are intentionally ignored.
+    for (const [key, value] of Object.entries(override)) {
+      InternalRecord.assignProperty(spec as any, key, value)
+    }
   })
   processAnnotation(api.annotations, Transform, (transformFn) => {
     spec = transformFn(spec) as OpenAPISpec
   })
 
-  apiCache.set(api, spec)
+  cache.set(api, spec)
 
   return spec
 }
@@ -793,7 +817,7 @@ function toEncodingAST(ast: SchemaAST.AST, _tag: HttpApiSchema.Encoding["_tag"])
 function persistedFileToBinaryEncoding(ast: SchemaAST.AST): SchemaAST.AST {
   if (
     SchemaAST.isDeclaration(ast) &&
-    ((ast.annotations as (Schema.Annotations.Declaration<unknown, readonly []> | undefined))?.typeConstructor?._tag ===
+    ((ast.annotations as (Schema.Annotations.Declaration<unknown, readonly []> | undefined))?.representation?.id ===
       "effect/http/PersistedFile")
   ) {
     return Uint8ArrayEncoding.ast

package/src/unstable/observability/OtlpExporter.ts

@@ -13,6 +13,9 @@ 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 FiberSet from "../../FiberSet.ts"
+import { identity } from "../../Function.ts"
+import * as Layer from "../../Layer.ts"
 import * as Num from "../../Number.ts"
 import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
@@ -41,6 +44,97 @@ const policy = Schedule.forever.pipe(
   })
 )
 
+/**
+ * Registry of exporter flush operations, used to manually drain buffered
+ * telemetry before the surrounding scope closes.
+ *
+ * **Details**
+ *
+ * Every exporter created by `make` registers its export operation here, so a
+ * single `flush` drains all signals sharing the registry. `flush` returns only
+ * after the exports it initiated have settled, cannot fail, and respects each
+ * exporter's temporary-disable window. Wrap it with `Effect.timeoutOption` to
+ * bound its duration at the call site.
+ *
+ * @category flushing
+ * @since 4.0.0
+ */
+export class Flusher extends Context.Service<Flusher, {
+  /**
+   * Drains all registered exporters concurrently and cannot fail.
+   *
+   * **Details**
+   *
+   * There is no built-in timeout; use `Effect.timeoutOption` to bound the
+   * operation. Exporters in their 60-second `disabledUntil` window are skipped.
+   *
+   * **Example** (Flushing from a Cloudflare Worker)
+   *
+   * ```ts
+   * import { Effect, ManagedRuntime } from "effect"
+   * import { OtlpExporter, OtlpTracer } from "effect/unstable/observability"
+   *
+   * const layer = OtlpTracer.layerFromConfig()
+   * const runtime = ManagedRuntime.make(layer)
+   *
+   * // In the request handler:
+   * ctx.waitUntil(
+   *   runtime.runPromise(
+   *     Effect.flatMap(OtlpExporter.Flusher, (flusher) => flusher.flush)
+   *   )
+   * )
+   * ```
+   */
+  readonly flush: Effect.Effect<void>
+  readonly register: (run: Effect.Effect<void>) => Effect.Effect<void, never, Scope.Scope>
+}>()(
+  "effect/observability/OtlpExporter/Flusher"
+) {}
+
+/**
+ * Provides a `Flusher` backed by a fresh registry.
+ *
+ * **Details**
+ *
+ * This is intentionally a single module-level constant rather than a factory:
+ * layer memoization is keyed by layer instance, so every signal layer
+ * referencing this same constant shares one registry per layer build, and one
+ * `flush` drains traces, logs and metrics together. A factory returning a new
+ * layer per call would silently create one registry per signal.
+ *
+ * Registration is scoped — an exporter is removed from the registry when its
+ * own scope closes. Flushing with an empty registry is a no-op.
+ *
+ * Note that `flush` cannot await an export that was already in flight when it
+ * was called (for example one started by the export interval); it only waits
+ * for the exports it initiates.
+ *
+ * @category flushing
+ * @since 4.0.0
+ */
+export const layerFlusher: Layer.Layer<Flusher> = Layer.sync(Flusher, () => {
+  const registry = new Set<Effect.Effect<void>>()
+  return {
+    flush: Effect.suspend(() => {
+      if (registry.size === 0) {
+        return Effect.void
+      }
+      return Effect.forEach(registry, identity, {
+        concurrency: "unbounded",
+        discard: true
+      })
+    }),
+    register: (run) =>
+      Effect.flatMap(Scope.Scope, (scope) => {
+        registry.add(run)
+        return Scope.addFinalizer(
+          scope,
+          Effect.sync(() => registry.delete(run))
+        )
+      })
+  }
+})
+
 /**
  * Creates a scoped OTLP batch exporter.
  *
@@ -67,12 +161,11 @@ export const make: (
 ) => Effect.Effect<
   { readonly push: (data: unknown) => void },
   never,
-  HttpClient.HttpClient | Scope.Scope
+  Flusher | HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
   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.fromInputUnsafe(options.exportInterval), Duration.zero)
   let disabledUntil: number | undefined = undefined
 
@@ -122,9 +215,19 @@ export const make: (
     })
   )
 
+  const exportFibers = yield* FiberSet.make<void, never>()
+  const runExportFork = yield* FiberSet.runtime(exportFibers)<never>()
+
+  const flusher = yield* Flusher
+  yield* flusher.register(runExport)
+
   yield* Scope.addFinalizer(
     scope,
-    runExport.pipe(
+    Effect.suspend(() => {
+      if (disabledUntil !== undefined) return Effect.void
+      runExportFork(runExport)
+      return FiberSet.awaitEmpty(exportFibers)
+    }).pipe(
       Effect.ignore,
       Effect.interruptible,
       Effect.timeoutOption(options.shutdownTimeout)
@@ -132,7 +235,8 @@ export const make: (
   )
 
   yield* Effect.sleep(exportInterval).pipe(
-    Effect.andThen(runExport),
+    Effect.andThen(FiberSet.run(exportFibers, runExport)),
+    Effect.flatMap(Fiber.await),
     Effect.forever,
     Effect.forkIn(scope)
   )
@@ -142,7 +246,7 @@ export const make: (
       if (disabledUntil !== undefined) return
       buffer.push(data)
       if (options.maxBatchSize !== "disabled" && buffer.length >= options.maxBatchSize) {
-        Fiber.runIn(runFork(runExport), scope)
+        runExportFork(runExport)
       }
     }
   }

package/src/unstable/observability/OtlpLogger.ts

@@ -57,7 +57,7 @@ export const make: (
 ) => Effect.Effect<
   Logger.Logger<unknown, void>,
   never,
-  OtlpSerialization | HttpClient.HttpClient | Scope.Scope
+  Exporter.Flusher | OtlpSerialization | HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
   const serialization = yield* OtlpSerialization
   const otelResource = yield* OtlpResource.fromConfig(options.resource)
@@ -116,10 +116,10 @@ export const layer = (options: {
   readonly shutdownTimeout?: Duration.Input | undefined
   readonly excludeLogSpans?: boolean | undefined
   readonly mergeWithExisting?: boolean | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+}): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Logger.layer([make(options)], {
     mergeWithExisting: options.mergeWithExisting ?? true
-  })
+  }).pipe(Layer.provideMerge(Exporter.layerFlusher))
 
 /**
  * Creates an OTLP logs layer from OpenTelemetry configuration.
@@ -136,7 +136,7 @@ export const layerFromConfig = (options?: {
   readonly headers?: Headers.Input | undefined
   readonly excludeLogSpans?: boolean | undefined
   readonly mergeWithExisting?: boolean | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+}): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
       disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
@@ -145,7 +145,7 @@ export const layerFromConfig = (options?: {
     })
 
     if (disabled || !endpoint || !exporters.includes("otlp")) {
-      return Layer.empty
+      return Exporter.layerFlusher
     }
 
     const { baseTimeout, logsTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({

package/src/unstable/observability/OtlpMetrics.ts

@@ -67,6 +67,9 @@ export type AggregationTemporality = "cumulative" | "delta"
  * **Details**
  *
  * The exporter snapshots registered Effect metrics on the configured interval, serializes them with the selected aggregation temporality, and flushes during scope finalization up to `shutdownTimeout`.
+ * Manual flushing also triggers a snapshot. With delta temporality, each
+ * snapshot advances the previous-export state, so frequent flushes narrow the
+ * delta aggregation windows.
  *
  * @category constructors
  * @since 4.0.0
@@ -85,7 +88,7 @@ export const make: (options: {
 }) => Effect.Effect<
   void,
   never,
-  HttpClient.HttpClient | OtlpSerialization | Scope.Scope
+  Exporter.Flusher | HttpClient.HttpClient | OtlpSerialization | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
   const clock = yield* Clock
   const serialization = yield* OtlpSerialization
@@ -464,7 +467,8 @@ export const layer = (options: {
   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))
+}): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
+  Layer.effectDiscard(make(options)).pipe(Layer.provideMerge(Exporter.layerFlusher))
 
 /**
  * Creates an OTLP metrics layer from OpenTelemetry configuration.
@@ -479,7 +483,7 @@ export const layerFromConfig = (options?: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+}): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
       disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
@@ -487,7 +491,7 @@ export const layerFromConfig = (options?: {
       exporters: OtlpEnv.exporters("METRICS")
     })
     if (disabled || !endpoint || !exporters.includes("otlp")) {
-      return Layer.empty
+      return Exporter.layerFlusher
     }
 
     const { baseTimeout, metricsTimeout, exportTimeout, exportInterval, temporalityPreference } = yield* Config.all({

package/src/unstable/observability/OtlpTracer.ts

@@ -59,7 +59,7 @@ export const make: (
 ) => Effect.Effect<
   Tracer.Tracer,
   never,
-  OtlpSerialization | HttpClient.HttpClient | Scope.Scope
+  Exporter.Flusher | OtlpSerialization | HttpClient.HttpClient | Scope.Scope
 > = Effect.fnUntraced(function*(options) {
   const otelResource = yield* OtlpResource.fromConfig(options.resource)
   const serialization = yield* OtlpSerialization
@@ -134,7 +134,11 @@ export const layer: (options: {
   readonly maxBatchSize?: number | undefined
   readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
-}) => Layer.Layer<never, never, OtlpSerialization | HttpClient.HttpClient> = flow(make, Layer.effect(Tracer.Tracer))
+}) => Layer.Layer<Exporter.Flusher, never, OtlpSerialization | HttpClient.HttpClient> = flow(
+  make,
+  Layer.effect(Tracer.Tracer),
+  Layer.provideMerge(Exporter.layerFlusher)
+)
 
 /**
  * Creates an OTLP traces layer from OpenTelemetry configuration.
@@ -150,7 +154,7 @@ export const layerFromConfig = (options?: {
   } | undefined
   readonly headers?: Headers.Input | undefined
   readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+}): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
       disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
@@ -159,7 +163,7 @@ export const layerFromConfig = (options?: {
     })
 
     if (disabled || !endpoint || !exporters.includes("otlp")) {
-      return Layer.empty
+      return Exporter.layerFlusher
     }
 
     const { baseTimeout, tracesTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({

package/src/unstable/persistence/Persistable.ts

@@ -10,6 +10,7 @@
 import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as Request from "../../Request.ts"
 import * as Schema from "../../Schema.ts"
@@ -179,10 +180,10 @@ export const Class = <
     | ("requires" extends keyof Config ? Config["requires"] : never)
   > =>
 {
-  function Persistable(this: any, props: any) {
+  function Persistable(this: any, props: object | undefined) {
     this._tag = tag
     if (props) {
-      Object.assign(this, props)
+      InternalRecord.assignProperties(this, props)
     }
   }
   Persistable.prototype = {

package/src/unstable/persistence/RateLimiter.ts

@@ -362,8 +362,8 @@ export class RateLimitExceeded extends Schema.ErrorClass<RateLimitExceeded>(
   _tag: Schema.tag("RateLimitExceeded"),
   retryAfter: Schema.DurationFromMillis,
   key: Schema.String,
-  limit: Schema.Number,
-  remaining: Schema.Number
+  limit: Schema.Finite,
+  remaining: Schema.Finite
 }) {
   /**
    * Public message used when the rate limiter rejects a request.

package/src/unstable/persistence/Redis.ts

@@ -186,8 +186,8 @@ export const script = <Params extends ReadonlyArray<any>>(
   params: Params
   result: void
 }> =>
-  Object.assign(Object.create(ScriptProto), {
+  Object.setPrototypeOf({
     ...options,
     params: f,
     numberOfKeys: typeof options.numberOfKeys === "number" ? constant(options.numberOfKeys) : options.numberOfKeys
-  })
+  }, ScriptProto)