effect 4.0.0-beta.73 → 4.0.0-beta.75

package/src/unstable/cli/internal/parser.ts

@@ -329,6 +329,17 @@ type ConsumedFlagValue =
     readonly _tag: "Error"
     readonly error: CliError.InvalidValue
   }
+type ConsumedFlagValueWithTokens =
+  | {
+    readonly _tag: "Value"
+    readonly value: string | undefined
+    readonly tokens: ReadonlyArray<Token>
+  }
+  | {
+    readonly _tag: "Error"
+    readonly error: CliError.InvalidValue
+    readonly tokens: ReadonlyArray<Token>
+  }
 
 const isFlagToken = (t: Token): t is FlagToken => t._tag === "LongOption" || t._tag === "ShortOption"
 
@@ -407,60 +418,88 @@ const consumeFlagValue = (
   spec: FlagParam,
   negated = false
 ): ConsumedFlagValue => {
+  const consumed = consumeFlagValueWithTokens(cursor, token, spec, negated)
+  switch (consumed._tag) {
+    case "Value":
+      return {
+        _tag: "Value",
+        value: consumed.value
+      }
+    case "Error":
+      return {
+        _tag: "Error",
+        error: consumed.error
+      }
+  }
+}
+
+const consumeFlagValueWithTokens = (
+  cursor: TokenCursor,
+  token: FlagToken,
+  spec: FlagParam,
+  negated = false
+): ConsumedFlagValueWithTokens => {
   // Inline value has highest priority
   if (negated) {
     if (token.value !== undefined) {
       return {
         _tag: "Error",
-        error: invalidNegatedFlagValue(token, spec, token.value)
+        error: invalidNegatedFlagValue(token, spec, token.value),
+        tokens: []
       }
     }
 
     const literal = asBooleanLiteral(cursor.peek())
     if (literal !== undefined) {
-      cursor.take()
+      const literalToken = cursor.take()
       return {
         _tag: "Error",
-        error: invalidNegatedFlagValue(token, spec, literal)
+        error: invalidNegatedFlagValue(token, spec, literal),
+        tokens: literalToken === undefined ? [] : [literalToken]
       }
     }
 
     return {
       _tag: "Value",
-      value: "false"
+      value: "false",
+      tokens: []
     }
   }
 
   if (token.value !== undefined) {
     return {
       _tag: "Value",
-      value: token.value
+      value: token.value,
+      tokens: []
     }
   }
 
   // Boolean flags: check for explicit literal or default to "true"
   if (Primitive.isBoolean(spec.primitiveType)) {
     const literal = asBooleanLiteral(cursor.peek())
-    if (literal !== undefined) cursor.take()
+    const literalToken = literal !== undefined ? cursor.take() : undefined
     return {
       _tag: "Value",
-      value: literal ?? "true"
+      value: literal ?? "true",
+      tokens: literalToken === undefined ? [] : [literalToken]
     }
   }
 
   // Non-boolean: try to consume next Value token
   const next = cursor.peek()
   if (next?._tag === "Value") {
-    cursor.take()
+    const valueToken = cursor.take()
     return {
       _tag: "Value",
-      value: next.value
+      value: next.value,
+      tokens: valueToken === undefined ? [] : [valueToken]
     }
   }
 
   return {
     _tag: "Value",
-    value: undefined
+    value: undefined,
+    tokens: []
   }
 }
 
@@ -504,6 +543,161 @@ export const consumeKnownFlags = (
   return { flagMap, remainder, errors }
 }
 
+const extractFlagParams = (command: Command.Any): ReadonlyArray<FlagParam> => {
+  const commandImpl = toImpl(command)
+  const singles = commandImpl.config.flags.flatMap(Param.extractSingleParams)
+  return singles.filter(Param.isFlagParam)
+}
+
+const extractContextFlagParams = (command: Command.Any): ReadonlyArray<FlagParam> => {
+  const commandImpl = toImpl(command)
+  const singles = commandImpl.contextConfig.flags.flatMap(Param.extractSingleParams)
+  return singles.filter(Param.isFlagParam)
+}
+
+const resolveFromRegistries = (
+  token: FlagToken,
+  registries: ReadonlyArray<FlagRegistry>
+): ResolvedFlag | undefined => {
+  for (const registry of registries) {
+    const resolved = resolveFlag(token, registry)
+    if (resolved !== undefined) {
+      return resolved
+    }
+  }
+  return undefined
+}
+
+const preserveFlag = (
+  remainder: Array<Token>,
+  cursor: TokenCursor,
+  token: FlagToken,
+  resolved: ResolvedFlag
+): void => {
+  remainder.push(token)
+  const consumed = consumeFlagValueWithTokens(cursor, token, resolved.param, resolved.negated)
+  remainder.push(...consumed.tokens)
+}
+
+const localFlagWouldPrecedeSubcommand = (
+  token: FlagToken,
+  remainingTokens: ReadonlyArray<Token>,
+  resolved: ResolvedFlag,
+  subIndex: Map<string, Command<string, unknown, unknown, unknown, unknown>>,
+  registries: ReadonlyArray<FlagRegistry>
+): boolean => {
+  const cursor = makeCursor(remainingTokens)
+  consumeFlagValueWithTokens(cursor, token, resolved.param, resolved.negated)
+  for (let token = cursor.take(); token; token = cursor.take()) {
+    if (isFlagToken(token)) {
+      const known = resolveFromRegistries(token, registries)
+      if (known !== undefined) {
+        consumeFlagValueWithTokens(cursor, token, known.param, known.negated)
+      }
+      continue
+    }
+
+    if (token._tag === "Value") {
+      return subIndex.has(token.value)
+    }
+  }
+  return false
+}
+
+/**
+ * Consumes global flags while walking the command tree.
+ *
+ * Command-local flags take precedence over global flags at the selected command
+ * level. This lets commands reuse a global flag name, for example a subcommand
+ * with its own `--version <value>` flag overriding the built-in global
+ * `--version` action.
+ * @internal
+ */
+export const consumeGlobalFlags = (
+  tokens: ReadonlyArray<Token>,
+  command: Command.Any,
+  registry: FlagRegistry
+): { flagMap: FlagMap; remainder: ReadonlyArray<Token>; errors: ReadonlyArray<CliError.InvalidValue> } => {
+  const flagMap = createEmptyFlagMap(registry.params)
+  const errors: Array<CliError.InvalidValue> = []
+
+  const consumeLevel = (
+    tokens: ReadonlyArray<Token>,
+    command: Command.Any,
+    ignoredRegistries: ReadonlyArray<FlagRegistry>
+  ): ReadonlyArray<Token> => {
+    const localRegistry = createFlagRegistry(extractFlagParams(command))
+    const inheritedRegistry = createFlagRegistry(extractContextFlagParams(command))
+    const subIndex = buildSubcommandIndex(command.subcommands)
+    const cursor = makeCursor(tokens)
+    const remainder: Array<Token> = []
+    let awaitingFirstValue = true
+
+    for (let token = cursor.take(); token; token = cursor.take()) {
+      if (isFlagToken(token)) {
+        const ignored = resolveFromRegistries(token, ignoredRegistries)
+        if (ignored !== undefined) {
+          preserveFlag(remainder, cursor, token, ignored)
+          continue
+        }
+
+        const inherited = resolveFlag(token, inheritedRegistry)
+        if (inherited !== undefined) {
+          preserveFlag(remainder, cursor, token, inherited)
+          continue
+        }
+
+        const local = resolveFlag(token, localRegistry)
+        const global = resolveFlag(token, registry)
+        if (local !== undefined) {
+          if (
+            global === undefined || !awaitingFirstValue ||
+            !localFlagWouldPrecedeSubcommand(token, cursor.rest(), local, subIndex, [
+              localRegistry,
+              inheritedRegistry,
+              registry
+            ])
+          ) {
+            preserveFlag(remainder, cursor, token, local)
+            continue
+          }
+        }
+
+        if (global !== undefined) {
+          const consumed = consumeFlagValueWithTokens(cursor, token, global.param, global.negated)
+          if (consumed._tag === "Error") {
+            errors.push(consumed.error)
+            continue
+          }
+          if (consumed.value !== undefined) {
+            flagMap[global.param.name].push(consumed.value)
+          }
+          continue
+        }
+
+        remainder.push(token)
+        continue
+      }
+
+      if (token._tag === "Value" && awaitingFirstValue) {
+        const sub = subIndex.get(token.value)
+        if (sub !== undefined) {
+          remainder.push(token)
+          remainder.push(...consumeLevel(cursor.rest(), sub, [...ignoredRegistries, inheritedRegistry]))
+          return remainder
+        }
+        awaitingFirstValue = false
+      }
+
+      remainder.push(token)
+    }
+
+    return remainder
+  }
+
+  return { flagMap, remainder: consumeLevel(tokens, command, []), errors }
+}
+
 /* ========================================================================== */
 /* Error Creation                                                             */
 /* ========================================================================== */

package/src/unstable/cluster/ClusterCron.ts

@@ -87,8 +87,7 @@ export const make = <E, R>(options: {
    *
    * **When to use**
    *
-   * Use when this is useful to prevent running jobs that were scheduled too far in the
-   * past.
+   * Use to prevent running jobs that were scheduled too far in the past.
    *
    * **Details**
    *

package/src/unstable/cluster/ClusterMetrics.ts

@@ -29,6 +29,11 @@ import * as Metric from "../../Metric.ts"
  * Creates a gauge tracking the number of active entity instances for each entity type on
  * the current runner.
  *
+ * **When to use**
+ *
+ * Use when instrumenting runner-local entity counts and tagging them by entity
+ * type for cluster dashboards.
+ *
  * **Details**
  *
  * Bigint gauge named `effect_cluster_entities`, updated with the entity type as

package/src/unstable/cluster/ClusterSchema.ts

@@ -71,7 +71,7 @@ export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchem
  *
  * **When to use**
  *
- * Use when a request needs server-side handling or storage work wrapped in the
+ * Use when you need server-side request handling or storage work wrapped in the
  * storage transaction.
  *
  * **Details**
@@ -135,8 +135,8 @@ export const isUninterruptibleForServer = (context: Context.Context<never>): boo
  *
  * **When to use**
  *
- * Use when client-side cluster request handling needs to decide whether an
- * interrupt should be ignored.
+ * Use when you need client-side cluster request handling to decide whether to
+ * ignore an interrupt.
  *
  * **Details**
  *

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -120,11 +120,11 @@ export const make = Effect.gen(function*() {
     >
   >()
   const ensureEntity = (workflow: Workflow.Any) => {
-    let entity = entities.get(workflow.name)
+    let entity = entities.get(workflow._tag)
     if (!entity) {
       entity = makeWorkflowEntity(workflow) as any
-      workflows.set(workflow.name, workflow)
-      entities.set(workflow.name, entity as any)
+      workflows.set(workflow._tag, workflow)
+      entities.set(workflow._tag, entity as any)
     }
     return entity!
   }
@@ -248,7 +248,7 @@ export const make = Effect.gen(function*() {
     }) {
       const requestId = yield* requestIdFor({
         workflow: options.workflow,
-        entityType: `Workflow/${options.workflow.name}`,
+        entityType: `Workflow/${options.workflow._tag}`,
         executionId: options.executionId,
         tag: "activity",
         id: activityPrimaryKey(options.activity.name, options.attempt)
@@ -283,7 +283,7 @@ export const make = Effect.gen(function*() {
   const resume = Effect.fnUntraced(function*(workflow: Workflow.Any, executionId: string) {
     const maybeReply = yield* requestReply({
       workflow,
-      entityType: `Workflow/${workflow.name}`,
+      entityType: `Workflow/${workflow._tag}`,
       executionId,
       tag: "run",
       id: ""
@@ -324,7 +324,7 @@ export const make = Effect.gen(function*() {
       ensureEntity(workflow)
       const requestId = yield* requestIdFor({
         workflow,
-        entityType: `Workflow/${workflow.name}`,
+        entityType: `Workflow/${workflow._tag}`,
         executionId,
         tag: "run",
         id: ""
@@ -343,7 +343,7 @@ export const make = Effect.gen(function*() {
       }
 
       yield* engine.deferredDone(InterruptSignal, {
-        workflowName: workflow.name,
+        workflowName: workflow._tag,
         executionId,
         deferredName: InterruptSignal.name,
         exit: Exit.void
@@ -457,13 +457,13 @@ export const make = Effect.gen(function*() {
 
     execute: (workflow, { discard, executionId, parent, payload }) => {
       ensureEntity(workflow)
-      return RcMap.get(clients, workflow.name).pipe(
+      return RcMap.get(clients, workflow._tag).pipe(
         Effect.flatMap((make) =>
           make(executionId).run(
             parent ?
               {
                 ...payload,
-                [payloadParentKey]: { workflowName: parent.workflow.name, executionId: parent.executionId }
+                [payloadParentKey]: { workflowName: parent.workflow._tag, executionId: parent.executionId }
               } :
               payload,
             { discard }
@@ -479,7 +479,7 @@ export const make = Effect.gen(function*() {
       const exitSchema = Schema.toCodecJson(Rpc.exitSchema(entity.protocol.requests.get("run")!))
       const reply = yield* requestReply({
         workflow,
-        entityType: `Workflow/${workflow.name}`,
+        entityType: `Workflow/${workflow._tag}`,
         executionId,
         tag: "run",
         id: ""
@@ -505,7 +505,7 @@ export const make = Effect.gen(function*() {
             id: yield* sharding.getSnowflake,
             address: entityAddressFor({
               workflow,
-              entityType: `Workflow/${workflow.name}`,
+              entityType: `Workflow/${workflow._tag}`,
               executionId
             }),
             requestId: requestId.value
@@ -523,7 +523,7 @@ export const make = Effect.gen(function*() {
         const instance = Context.get(services, WorkflowEngine.WorkflowInstance)
         yield* Effect.annotateCurrentSpan("executionId", instance.executionId)
         const activityId = `${instance.executionId}/${activity.name}`
-        const client = (yield* RcMap.get(clientsPartial, instance.workflow.name))(instance.executionId)
+        const client = (yield* RcMap.get(clientsPartial, instance.workflow._tag))(instance.executionId)
         while (true) {
           if (!activities.has(activityId)) {
             activities.set(activityId, { activity, context: services })
@@ -563,7 +563,7 @@ export const make = Effect.gen(function*() {
         Effect.flatMap((instance) =>
           requestReply({
             workflow: instance.workflow,
-            entityType: `Workflow/${instance.workflow.name}`,
+            entityType: `Workflow/${instance.workflow._tag}`,
             executionId: instance.executionId,
             tag: "deferred",
             id: deferred.name
@@ -628,7 +628,7 @@ export const make = Effect.gen(function*() {
             }),
             payload: {
               name: options.clock.name,
-              workflowName: workflow.name,
+              workflowName: workflow._tag,
               wakeUp: DateTime.addDuration(now, options.clock.duration)
             }
           })
@@ -701,7 +701,7 @@ const ResumeRpc = Rpc.make("resume", {
 const payloadParentKey = "~effect/cluster/ClusterWorkflowEngine/payloadParentKey"
 
 const makeWorkflowEntity = (workflow: Workflow.Any) =>
-  Entity.make(`Workflow/${workflow.name}`, [
+  Entity.make(`Workflow/${workflow._tag}`, [
     Rpc.make("run", {
       payload: {
         ...workflow.payloadSchema.fields,

package/src/unstable/cluster/Entity.ts

@@ -574,7 +574,7 @@ export declare namespace Replier {
  * It includes the underlying request envelope plus the last stream reply chunk
  * that was sent, allowing handlers to resume chunk sequencing after a restart.
  *
- * @category Request
+ * @category request
  * @since 4.0.0
  */
 export class Request<Rpc extends Rpc.Any> extends Data.Class<

package/src/unstable/cluster/EntityResource.ts

@@ -71,6 +71,11 @@ export interface EntityResource<out A, out E = never> {
 /**
  * Context service for a Scope that is only closed when the resource is explicitly closed.
  *
+ * **When to use**
+ *
+ * Use when a cluster entity resource needs a scope that survives restarts and
+ * closes only through the resource lifecycle.
+ *
  * **Gotchas**
  *
  * It is not closed during restarts, due to shard movement or node shutdowns.
@@ -86,6 +91,11 @@ export class CloseScope extends Context.Service<
 /**
  * Creates an `EntityResource` that can be acquired inside a cluster entity.
  *
+ * **When to use**
+ *
+ * Use when a cluster entity should lazily share an acquired resource across
+ * messages and release it only on idle timeout or explicit close.
+ *
  * **Details**
  *
  * The resource will only be fully released when the idle time to live is

package/src/unstable/cluster/Envelope.ts

@@ -28,7 +28,7 @@ import * as Predicate from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import * as Headers from "../http/Headers.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import { EntityAddress } from "./EntityAddress.ts"
@@ -406,10 +406,10 @@ export const Request = Schema.declare(
  * @category serialization
  * @since 4.0.0
  */
-export const RequestTransform: Transformation.Transformation<
+export const RequestTransform: SchemaTransformation.Transformation<
   Request.Any,
   any
-> = Transformation.transform({
+> = SchemaTransformation.transform({
   decode: (u: any) => makeRequest(u),
   encode: (u) => u as any
 })

package/src/unstable/cluster/HttpRunner.ts

@@ -166,7 +166,7 @@ export const layerClientProtocolWebsocketDefault: Layer.Layer<
  * The returned effect is produced from `RunnerServer.layerHandlers` and the
  * cluster runner RPC group.
  *
- * @category Http App
+ * @category http app
  * @since 4.0.0
  */
 export const toHttpEffect: Effect.Effect<
@@ -189,7 +189,7 @@ export const toHttpEffect: Effect.Effect<
  * The returned effect is produced from `RunnerServer.layerHandlers` and the
  * cluster runner RPC group.
  *
- * @category Http App
+ * @category http app
  * @since 4.0.0
  */
 export const toHttpEffectWebsocket: Effect.Effect<

package/src/unstable/cluster/K8sHttpClient.ts

@@ -56,7 +56,7 @@ import * as HttpClientResponse from "../http/HttpClientResponse.ts"
 /**
  * Service tag for the HTTP client used to call the Kubernetes API.
  *
- * @category Tags
+ * @category services
  * @since 4.0.0
  */
 export class K8sHttpClient extends Context.Service<

package/src/unstable/cluster/Reply.ts

@@ -30,9 +30,9 @@ import * as Exit from "../../Exit.ts"
 import * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as Issue from "../../SchemaIssue.ts"
-import * as Parser from "../../SchemaParser.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
+import * as SchemaParser from "../../SchemaParser.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type * as RpcMessage from "../rpc/RpcMessage.ts"
 import type * as RpcSchema from "../rpc/RpcSchema.ts"
@@ -221,7 +221,7 @@ export class Chunk<R extends Rpc.Any> extends Data.TaggedClass("Chunk")<{
    *
    * @since 4.0.0
    */
-  static readonly transform: Transformation.Transformation<any, any> = Transformation.transform({
+  static readonly transform: SchemaTransformation.Transformation<any, any> = SchemaTransformation.transform({
     decode: (a: any) => new Chunk(a),
     encode: (a) => a as any
   })
@@ -254,10 +254,11 @@ export class Chunk<R extends Rpc.Any> extends Data.TaggedClass("Chunk")<{
       [success],
       ([success]) => (input, ast, options) => {
         if (!isReply(input) || input._tag !== "Chunk") {
-          return Effect.fail(new Issue.InvalidType(ast, Option.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input)))
         }
-        return Effect.mapBothEager(Parser.decodeEffect(Schema.NonEmptyArray(success))(input.values, options), {
-          onFailure: (issue) => new Issue.Composite(ast, Option.some(input), [new Issue.Pointer(["values"], issue)]),
+        return Effect.mapBothEager(SchemaParser.decodeEffect(Schema.NonEmptyArray(success))(input.values, options), {
+          onFailure: (issue) =>
+            new SchemaIssue.Composite(ast, Option.some(input), [new SchemaIssue.Pointer(["values"], issue)]),
           onSuccess: (values) => new Chunk({ ...input, values } as any)
         })
       },
@@ -272,7 +273,7 @@ export class Chunk<R extends Rpc.Any> extends Data.TaggedClass("Chunk")<{
               sequence: Schema.Number,
               values: Schema.NonEmptyArray(success)
             }),
-            Transformation.transform({
+            SchemaTransformation.transform({
               decode: (encoded) => new Chunk(encoded),
               encode: (result) => ({ ...result })
             })
@@ -359,10 +360,11 @@ export class WithExit<R extends Rpc.Any> extends Data.TaggedClass("WithExit")<{
       [exitSchema],
       ([exit]) => (input, ast, options) => {
         if (!isReply(input) || input._tag !== "WithExit") {
-          return Effect.fail(new Issue.InvalidType(ast, Option.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input)))
         }
-        return Effect.mapBothEager(Parser.decodeEffect(exit)(input.exit, options), {
-          onFailure: (issue) => new Issue.Composite(ast, Option.some(input), [new Issue.Pointer(["exit"], issue)]),
+        return Effect.mapBothEager(SchemaParser.decodeEffect(exit)(input.exit, options), {
+          onFailure: (issue) =>
+            new SchemaIssue.Composite(ast, Option.some(input), [new SchemaIssue.Pointer(["exit"], issue)]),
           onSuccess: (exit) => new WithExit({ ...input, exit: exit as any })
         })
       },
@@ -376,7 +378,7 @@ export class WithExit<R extends Rpc.Any> extends Data.TaggedClass("WithExit")<{
               id: SnowflakeFromBigInt,
               exit
             }),
-            Transformation.transform({
+            SchemaTransformation.transform({
               decode: (encoded) => new WithExit(encoded as any),
               encode: (result) => ({ ...result })
             })

package/src/unstable/cluster/RunnerHealth.ts

@@ -71,7 +71,8 @@ export class RunnerHealth extends Context.Service<
  *
  * **When to use**
  *
- * Use when tests or local development do not need active runner health checks.
+ * Use when you need a runner-health layer for tests or local development where
+ * active health checks are unnecessary.
  *
  * @category layers
  * @since 4.0.0

package/src/unstable/cluster/RunnerServer.ts

@@ -212,8 +212,8 @@ export const layerWithClients: Layer.Layer<
  *
  * **When to use**
  *
- * Use when you use this layer to embed a cluster client inside another Effect application
- * without registering with the ShardManager or receiving shard assignments.
+ * Use to embed a cluster client inside another Effect application without registering with
+ * the ShardManager or receiving shard assignments.
  *
  * @category layers
  * @since 4.0.0

package/src/unstable/cluster/Runners.ts

@@ -152,9 +152,9 @@ export class Runners extends Context.Service<Runners, {
  *
  * **When to use**
  *
- * Use to build a custom `Runners` service when you already have remote `ping`,
- * `send`, `notify`, and `onRunnerUnavailable` callbacks and want the standard
- * local persistence and reply recovery behavior added around them.
+ * Use when you need a custom `Runners` service around remote `ping`, `send`,
+ * `notify`, and `onRunnerUnavailable` callbacks, with standard local
+ * persistence and reply recovery behavior.
  *
  * **Details**
  *
@@ -702,7 +702,7 @@ export const layerRpc: Layer.Layer<
  * Service that creates an RPC client protocol for communicating with a runner at a
  * given address.
  *
- * @category Client
+ * @category client
  * @since 4.0.0
  */
 export class RpcClientProtocol extends Context.Service<

package/src/unstable/cluster/ShardId.ts

@@ -29,7 +29,7 @@ import * as Hash from "../../Hash.ts"
 import { hasProperty } from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as S from "../../Schema.ts"
-import * as Getter from "../../SchemaGetter.ts"
+import * as SchemaGetter from "../../SchemaGetter.ts"
 
 const TypeId = "~effect/cluster/ShardId"
 
@@ -69,8 +69,8 @@ export const ShardId = S.declare(isShardId, {
         id: S.Number
       }),
       {
-        decode: Getter.transform(({ group, id }) => make(group, id)),
-        encode: Getter.passthrough()
+        decode: SchemaGetter.transform(({ group, id }) => make(group, id)),
+        encode: SchemaGetter.passthrough()
       }
     )
 })