effect 4.0.0-beta.0 → 4.0.0-beta.10

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -4,7 +4,6 @@
 import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import type { Effect } from "../../Effect.ts"
-import { format } from "../../Formatter.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -71,9 +70,9 @@ export interface HttpApiEndpoint<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -156,21 +155,6 @@ export interface HttpApiEndpoint<
   >
 }
 
-/** @internal */
-export function getParamsSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.params ? Schema.Struct(endpoint.params) : undefined
-}
-
-/** @internal */
-export function getQuerySchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.query ? Schema.Struct(endpoint.query) : undefined
-}
-
-/** @internal */
-export function getHeadersSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.headers ? Schema.Struct(endpoint.headers) : undefined
-}
-
 /** @internal */
 export function getPayloadSchemas(endpoint: AnyWithProps): Array<Schema.Top> {
   const result: Array<Schema.Top> = []
@@ -830,9 +814,9 @@ function makeProto<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -855,32 +839,28 @@ function makeProto<
 }
 
 /**
- * Params come from the router as `string` (optional params as `undefined`) and
- * must be encodable back into the URL path.
- *
- * We accept "struct fields" (`Record<string, Codec<...>>`) so we can both enforce
- * `Encoded` = `string | undefined` per field and reliably generate OpenAPI
- * `in: path` parameters by iterating object properties.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type ParamsConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+export type ParamsConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
 
 /**
- * URL search params can be repeated, so fields may encode to `string` or
- * `ReadonlyArray<string>` (or be missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: query` parameters.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type QuerySchemaConstraint = Record<
-  string,
-  Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
->
+export type HeadersConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
+
+/**
+ * @since 4.0.0
+ * @category constraints
+ */
+export type QueryConstraint =
+  | Record<string, Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | ReadonlyArray<string> | undefined>, unknown>
 
 /**
  * Payload schema depends on the HTTP method:
@@ -893,34 +873,23 @@ export type QuerySchemaConstraint = Record<
  * @since 4.0.0
  * @category constraints
  */
-export type PayloadSchemaConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
+export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
     string,
     Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
   > :
-  SuccessSchemaConstraint
-
-/**
- * HTTP headers are string-valued (or missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: header` parameters.
- *
- * @since 4.0.0
- * @category constraints
- */
-export type HeadersSchemaConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+  SuccessConstraint
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type SuccessSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type SuccessConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type ErrorSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
@@ -931,11 +900,11 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   const Name extends string,
   const Path extends HttpRouter.PathInput,
   Params extends ParamsConstraint = never,
-  Query extends QuerySchemaConstraint = never,
-  Payload extends PayloadSchemaConstraint<Method> = never,
-  Headers extends HeadersSchemaConstraint = never,
-  const Success extends SuccessSchemaConstraint = HttpApiSchema.NoContent,
-  const Error extends ErrorSchemaConstraint = never
+  Query extends QueryConstraint = never,
+  Payload extends PayloadConstraint<Method> = never,
+  Headers extends HeadersConstraint = never,
+  const Success extends SuccessConstraint = HttpApiSchema.NoContent,
+  const Error extends ErrorConstraint = never
 >(
   name: Name,
   path: Path,
@@ -964,8 +933,8 @@ export const make = <Method extends HttpMethod>(method: Method) =>
     name,
     path,
     method,
-    params: options?.params,
-    query: options?.query,
+    params: getParams(options?.params),
+    query: getQuery(options?.query),
     headers: getHeaders(options?.headers),
     payload: getPayload(options?.payload),
     success: getSuccess(options?.success),
@@ -975,17 +944,23 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   })
 }
 
+function getParams(params: ParamsConstraint | undefined): Schema.Top | undefined {
+  if (params === undefined) return undefined
+  if (Schema.isSchema(params)) return params
+  return Schema.Struct(params)
+}
+
+function getQuery(query: QueryConstraint | undefined): Schema.Top | undefined {
+  if (query === undefined) return undefined
+  if (Schema.isSchema(query)) return query
+  return Schema.Struct(query)
+}
+
 // all keys should be lowercase
-function getHeaders(headers: Schema.Struct.Fields | undefined): Schema.Struct.Fields | undefined {
-  if (headers !== undefined) {
-    for (const key of Object.keys(headers)) {
-      const lowerKey = key.toLowerCase()
-      if (key !== lowerKey) {
-        throw new Error(`Header keys must be lowercase, got ${format(key)} (use ${format(lowerKey)})`)
-      }
-    }
-    return headers
-  }
+function getHeaders(headers: HeadersConstraint | undefined): Schema.Top | undefined {
+  if (headers === undefined) return undefined
+  if (Schema.isSchema(headers)) return headers
+  return Schema.Struct(headers)
 }
 
 function getPayload(

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -98,6 +98,12 @@ export type ScalarConfig = {
    * Default: `false`
    */
   defaultOpenAllTags?: boolean
+  /**
+   * Whether to display the operation ID in the operation reference.
+   *
+   * Default: `false`
+   */
+  showOperationId?: boolean
 }
 
 type ScalarSource =

package/src/unstable/httpapi/OpenApi.ts

@@ -362,20 +362,23 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         }
       }
 
-      function processParameters(fields: Schema.Struct.Fields | undefined, i: OpenAPISpecParameter["in"]) {
-        if (fields) {
-          for (const [name, field] of Object.entries(fields)) {
-            op.parameters.push({
-              name: String(name),
-              in: i,
-              schema: {},
-              required: i === "path" || !AST.isOptional(field.ast)
-            })
-            pathOps.push({
-              _tag: "parameter",
-              ast: AST.toEncoded(field.ast),
-              path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
-            })
+      function processParameters(schema: Schema.Top | undefined, i: OpenAPISpecParameter["in"]) {
+        if (schema) {
+          const ast = AST.toEncoded(schema.ast)
+          if (AST.isObjects(ast)) {
+            for (const ps of ast.propertySignatures) {
+              op.parameters.push({
+                name: String(ps.name),
+                in: i,
+                schema: {},
+                required: i === "path" || !AST.isOptional(ps.type)
+              })
+              pathOps.push({
+                _tag: "parameter",
+                ast: ps.type,
+                path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
+              })
+            }
           }
         }
       }
@@ -421,8 +424,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       processParameters(endpoint.params, "path")
       if (!hasBody && endpoint.payload.size === 1) {
         const entry = endpoint.payload.values().next().value!
-        const schema = entry.schemas[0] as Schema.Struct<Schema.Struct.Fields>
-        processParameters(schema.fields, "query")
+        processParameters(entry.schemas[0], "query")
       }
       processParameters(endpoint.headers, "header")
       processParameters(endpoint.query, "query")

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

@@ -40,10 +40,10 @@ 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 },
@@ -54,7 +54,7 @@ export const make: (
   const clock = ServiceMap.get(services, Clock)
   const scope = ServiceMap.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(

package/src/unstable/observability/OtlpLogger.ts

@@ -30,9 +30,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<
@@ -85,9 +85,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> =>

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,
@@ -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/OtlpTracer.ts

@@ -32,10 +32,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 +109,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

package/src/unstable/persistence/KeyValueStore.ts

@@ -3,7 +3,7 @@
  */
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { dual, identity, type LazyArg } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
@@ -225,7 +225,7 @@ export const makeStringOnly = (
     getUint8Array: (key) =>
       options.get(key).pipe(
         Effect.map(UndefinedOr.map((value) =>
-          Result.match(Base64.decode(value), {
+          Result.match(Encoding.decodeBase64(value), {
             onFailure: () => encoder.encode(value),
             onSuccess: identity
           })
@@ -234,7 +234,7 @@ export const makeStringOnly = (
     set: (key, value) =>
       typeof value === "string"
         ? options.set(key, value)
-        : Effect.suspend(() => options.set(key, Base64.encode(value)))
+        : Effect.suspend(() => options.set(key, Encoding.encodeBase64(value)))
   })
 }
 
@@ -276,7 +276,7 @@ export const layerMemory: Layer.Layer<KeyValueStore> = Layer.sync(KeyValueStore)
     get: (key: string) =>
       Effect.sync(() => {
         const value = store.get(key)
-        return value === undefined ? undefined : typeof value === "string" ? value : Base64.encode(value)
+        return value === undefined ? undefined : typeof value === "string" ? value : Encoding.encodeBase64(value)
       }),
     getUint8Array: (key: string) =>
       Effect.sync(() => {
@@ -312,7 +312,7 @@ export const layerFileSystem = (
           fs.readFileString(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "get",
                 key,
@@ -326,7 +326,7 @@ export const layerFileSystem = (
           fs.readFile(keyPath(key)),
           "PlatformError",
           (cause) =>
-            cause.reason._tag === "SystemError" && cause.reason.kind === "NotFound" ? Effect.undefined : Effect.fail(
+            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
               new KeyValueStoreError({
                 method: "getUint8Array",
                 key,

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

package/src/unstable/persistence/PersistedCache.ts

@@ -17,18 +17,18 @@ const TypeId = "~effect/persistence/PersistedCache" as const
  * @since 4.0.0
  * @category Models
  */
-export interface PersistedCache<K extends Persistable.Any> {
+export interface PersistedCache<K extends Persistable.Any, out R = never> {
   readonly [TypeId]: typeof TypeId
   readonly inMemory: Cache.Cache<
     K,
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly get: (key: K) => Effect.Effect<
     Persistable.Success<K>,
     Persistable.Error<K> | Persistence.PersistenceError | Schema.SchemaError,
-    Persistable.Services<K>
+    Persistable.Services<K> | R
   >
   readonly invalidate: (key: K) => Effect.Effect<void, Persistence.PersistenceError>
 }
@@ -37,22 +37,32 @@ export interface PersistedCache<K extends Persistable.Any> {
  * @since 4.0.0
  * @category Constructors
  */
-export const make: <K extends Persistable.Any, R>(options: {
+export const make: <
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(options: {
   readonly storeId: string
   readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+  readonly requireServicesAt?: ServiceMode | undefined
 }) => Effect.Effect<
-  PersistedCache<K>,
+  PersistedCache<K, "lookup" extends ServiceMode ? R : never>,
   never,
-  R | Persistence.Persistence | Scope.Scope
-> = Effect.fnUntraced(function*<K extends Persistable.Any, R>(options: {
+  ("lookup" extends ServiceMode ? never : R) | Persistence.Persistence | Scope.Scope
+> = Effect.fnUntraced(function*<
+  K extends Persistable.Any,
+  R = never,
+  ServiceMode extends "lookup" | "construction" = never
+>(options: {
   readonly storeId: string
   readonly lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>
   readonly timeToLive: Persistable.TimeToLiveFn<K>
   readonly inMemoryCapacity?: number | undefined
   readonly inMemoryTTL?: Persistable.TimeToLiveFn<K> | undefined
+  readonly requireServicesAt?: ServiceMode | undefined
 }) {
   const store = yield* (yield* Persistence.Persistence).make({
     storeId: options.storeId,
@@ -69,9 +79,10 @@ export const make: <K extends Persistable.Any, R>(options: {
       return yield* result
     }),
     timeToLive: options.inMemoryTTL ?? constant(Duration.seconds(10)),
-    capacity: options.inMemoryCapacity ?? 1024
+    capacity: options.inMemoryCapacity ?? 1024,
+    requireServicesAt: options.requireServicesAt
   })
-  return identity<PersistedCache<K>>({
+  return identity<PersistedCache<K, "lookup" extends ServiceMode ? R : never>>({
     [TypeId]: TypeId,
     inMemory,
     get: (key) => Cache.get(inMemory, key),