alchemy 2.0.0-beta.43 → 2.0.0-beta.45

package/src/Plan.ts

@@ -1,4 +1,5 @@
 import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
@@ -18,6 +19,7 @@ import {
   makeScopedArtifacts,
 } from "./Artifacts.ts";
 import {
+  dedupeBindings,
   diffBindings,
   havePropsChanged,
   isResolved,
@@ -309,7 +311,11 @@ export const make = <A>(
                   : oldState.props;
 
               const oldBindings = oldState.bindings ?? [];
-              const newBindings = stack.bindings[resource.FQN] ?? [];
+              // Collapse duplicate bindings by sid so the binding set handed to
+              // `diff` matches what `reconcile` receives (see `dedupeBindings`).
+              const newBindings = dedupeBindings(
+                stack.bindings[resource.FQN] ?? [],
+              );
 
               const diff = yield* provider.diff
                 ? provider
@@ -375,6 +381,11 @@ export const make = <A>(
           return yield* resolveOutput(input);
         } else if (Redacted.isRedacted(input)) {
           return input;
+        } else if (Duration.isDuration(input)) {
+          // Duration is an opaque value; walking its internal `.value`
+          // would destroy the prototype and produce a plain `{ value: ... }`
+          // object that downstream consumers can't interpret.
+          return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {
             concurrency: "unbounded",
@@ -627,8 +638,10 @@ export const make = <A>(
             const news = yield* resolveInput(resource.Props);
             const downstream = newDownstreamDependencies[fqn] ?? [];
 
-            const newBindings: ResourceBinding[] = yield* resolveInput(
-              stack.bindings[fqn] ?? [],
+            // Collapse duplicate bindings by sid so the binding set handed to
+            // `diff` matches what `reconcile` receives (see `dedupeBindings`).
+            const newBindings: ResourceBinding[] = dedupeBindings(
+              yield* resolveInput(stack.bindings[fqn] ?? []),
             );
             const persisted = yield* state.get({
               stack: stackName,

package/src/Platform.ts

@@ -1,3 +1,5 @@
+import * as ConfigError from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
@@ -7,14 +9,21 @@ import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import { SingleShotGen } from "effect/Utils";
 import type { PolicyLike } from "./Binding.ts";
+import type { Dependencies } from "./Dependencies.ts";
 import type { ExecutionContext } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
 import type { InputProps } from "./Input.ts";
+import * as Output from "./Output.ts";
 import { ALCHEMY_PHASE } from "./Phase.ts";
 import type { Provider, ProviderCollectionLike } from "./Provider.ts";
 import { Resource, type ResourceLike } from "./Resource.ts";
 import type { Rpc } from "./Rpc.ts";
-import { RuntimeContext, type BaseRuntimeContext } from "./RuntimeContext.ts";
+import {
+  CurrentRuntimeContext,
+  RuntimeContext,
+  sanitizeKey,
+  type BaseRuntimeContext,
+} from "./RuntimeContext.ts";
 import { Self } from "./Self.ts";
 import type { Stack, StackServices } from "./Stack.ts";
 import type { Stage } from "./Stage.ts";
@@ -65,19 +74,19 @@ export interface Platform<
   Type: Resource["Type"];
   Provider: Provider<Resource>;
 
-  <Self, Shape>(): {
+  <Self, Shape, Deps = never>(): {
     <PropsReq = never>(
       id: string,
       props:
         | InputProps<Resource["Props"]>
         | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
     ): Effect.Effect<
-      Resource & Rpc<Self>,
+      Resource & Rpc<Self> & Dependencies<Deps>,
       never,
-      Self | Resource["Providers"] | PropsReq
+      Resource["Providers"] | PropsReq
     > & {
       make<InitReq = never>(
-        impl: Effect.Effect<Shape, never, InitReq>,
+        impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
       ): Layer.Layer<
         Self,
         never,
@@ -98,7 +107,7 @@ export interface Platform<
       props:
         | InputProps<Resource["Props"]>
         | Effect.Effect<Resource["Props"], never, PropsReq>,
-      impl: Effect.Effect<Shape, never, InitReq>,
+      impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
@@ -119,7 +128,7 @@ export interface Platform<
       Resource["Providers"] | PropsReq
     > & {
       make<InitReq extends Services | PlatformServices = never>(
-        impl: Effect.Effect<Shape, never, InitReq>,
+        impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
       ): Layer.Layer<
         Self,
         never,
@@ -158,7 +167,7 @@ export interface Platform<
     props:
       | InputProps<Resource["Props"]>
       | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
-    impl: Effect.Effect<Shape, never, InitReq>,
+    impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
@@ -343,28 +352,66 @@ export const Platform = <
                       }) ?? Effect.die("No serve handler"))
                     : Effect.void,
                 ),
+
                 Effect.provide(
-                  Layer.provideMerge(
-                    Layer.mergeAll(
-                      Layer.succeed(Platform.Platform, runtimeContext),
-                      Layer.succeed(PlatformContext, runtimeContext),
-                      Layer.succeed(RuntimeContext, runtimeContext),
-                      Layer.succeed(resource.Self, instance),
-                      Layer.succeed(Platform.Self, instance),
-                      Layer.succeed(Self, instance),
-                      runtimeContext.planServices
-                        ? Layer.unwrap(
-                            ALCHEMY_PHASE.pipe(
-                              Effect.map((phase) =>
-                                phase === "plan"
-                                  ? runtimeContext.planServices!
-                                  : Layer.empty,
+                  Layer.effect(
+                    ConfigProvider.ConfigProvider,
+                    Effect.gen(function* () {
+                      // a Config Provider that we use to intercept config lookups and bind them to the RuntimeContext
+                      const configProvider =
+                        yield* ConfigProvider.ConfigProvider;
+                      const phase = yield* ALCHEMY_PHASE;
+
+                      return ConfigProvider.make(
+                        Effect.fnUntraced(function* (path) {
+                          const ctx = yield* CurrentRuntimeContext;
+                          // `set`/`get` store keys verbatim, so canonicalize the
+                          // logical config path here (the caller's job) before
+                          // handing it to the RuntimeContext.
+                          const key = sanitizeKey(
+                            path.map((p) => p.toString()).join("_"),
+                          );
+                          const node = yield* configProvider.get(path);
+                          if (phase === "plan" && node) {
+                            // bind it to the RuntimeContext if running in plan phase
+                            const output = Output.literal(node.value);
+                            yield* ctx?.set(key, output) ?? Effect.void;
+                            return node;
+                          } else if (phase === "runtime" && ctx) {
+                            // retrieve from the RuntimeContext if running in runtime phase
+                            const value = yield* ctx.get<string>(key);
+                            if (value) {
+                              return ConfigProvider.makeValue(value as string);
+                            }
+                          }
+                          // fallback to the config provider otherwise
+                          return node;
+                        }),
+                      );
+                    }),
+                  ).pipe(
+                    Layer.provideMerge(
+                      Layer.mergeAll(
+                        Layer.succeed(Platform.Platform, runtimeContext),
+                        Layer.succeed(PlatformContext, runtimeContext),
+                        Layer.succeed(RuntimeContext, runtimeContext),
+                        Layer.succeed(resource.Self, instance),
+                        Layer.succeed(Platform.Self, instance),
+                        Layer.succeed(Self, instance),
+                        runtimeContext.planServices
+                          ? Layer.unwrap(
+                              ALCHEMY_PHASE.pipe(
+                                Effect.map((phase) =>
+                                  phase === "plan"
+                                    ? runtimeContext.planServices!
+                                    : Layer.empty,
+                                ),
                               ),
-                            ),
-                          )
-                        : Layer.empty,
+                            )
+                          : Layer.empty,
+                      ),
                     ),
-                    Layer.succeedContext(outerServices),
+                    Layer.provideMerge(Layer.succeedContext(outerServices)),
                   ),
                 ),
               );

package/src/Random.ts

@@ -32,34 +32,29 @@ export const Random = Resource<Random>("Alchemy.Random");
 
 export const RandomProvider = () =>
   Provider.succeed(Random, {
-    reconcile: Effect.fn(function* ({ news = {}, output }) {
-      // Observe — there is no remote state. The cached `output.text` is
-      // the authoritative current value; once minted it is preserved
-      // across reconciles to keep the secret stable.
-      if (output?.text) {
-        return output;
-      }
+    reconcile: ({ news = {}, output }) =>
+      Effect.sync(() => {
+        // Observe — there is no remote state. The cached `output.text` is
+        // the authoritative current value; once minted it is preserved
+        // across reconciles to keep the secret stable.
+        if (output?.text) {
+          return output;
+        }
 
-      // Ensure — no observed value: mint a fresh random secret and
-      // return it. The next reconcile will see this in `output` and
-      // short-circuit above.
-      const byteLength = news.bytes ?? 32;
-      const text = yield* Effect.sync(() => {
+        // Ensure — no observed value: mint a fresh random secret and
+        // return it. The next reconcile will see this in `output` and
+        // short-circuit above.
+        const byteLength = news.bytes ?? 32;
         const bytes = new Uint8Array(byteLength);
         crypto.getRandomValues(bytes);
-        return Redacted.make(
-          Array.from(bytes)
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join(""),
-        );
-      });
-
-      return { text };
-    }),
-    delete: Effect.fn(function* () {
-      return undefined;
-    }),
-    read: Effect.fn(function* ({ output }) {
-      return output;
-    }),
+        return {
+          text: Redacted.make(
+            Array.from(bytes)
+              .map((b) => b.toString(16).padStart(2, "0"))
+              .join(""),
+          ),
+        };
+      }),
+    delete: () => Effect.void,
+    read: ({ output }) => Effect.succeed(output),
   });

package/src/RuntimeContext.ts

@@ -9,7 +9,15 @@ export interface BaseRuntimeContext {
   Type: string;
   id: string;
   env: Record<string, any>;
-  get<T>(key: string): Effect.Effect<T>;
+  /**
+   * Read a value by its (already-canonical) key. The key is used verbatim;
+   * callers must {@link sanitizeKey} first. See {@link sanitizeKey}.
+   */
+  get<T>(key: string): Effect.Effect<T | undefined>;
+  /**
+   * Store an output under the given (already-canonical) key, returning the key.
+   * The key is used verbatim; callers must {@link sanitizeKey} first.
+   */
   set(id: string, output: Output): Effect.Effect<string>;
   exports?: Effect.Effect<Record<string, any>>;
   serve?<Req = never>(
@@ -21,6 +29,20 @@ export interface BaseRuntimeContext {
   planServices?: Layer.Layer<any>;
 }
 
+/**
+ * Canonicalize a logical key into a key that is safe to use as the name of an
+ * environment variable / binding (`[a-zA-Z][a-zA-Z0-9_]*`).
+ *
+ * `RuntimeContext.set`/`get` are dumb key/value stores: they read and write the
+ * key **verbatim**. It is the *caller's* responsibility to hand them a
+ * canonical key, since the caller is the one that knows the logical key may
+ * contain `.`/`-` (e.g. a dotted config name from `Platform`, or an
+ * `Output.toString()` like `"QueueSinkQueue.queueUrl"`). Callers run the key
+ * through this before calling `set`/`get` so both sides agree.
+ */
+export const sanitizeKey = (key: string): string =>
+  key.replaceAll(/[^a-zA-Z0-9]/g, "_");
+
 /**
  * Context of the runtime environment.
  *

package/src/Stack.ts

@@ -10,6 +10,7 @@ import * as Scope from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { ActionLike } from "./Action.ts";
 import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
 import { provideFreshArtifactStore } from "./Artifacts.ts";
 import { AuthProviders } from "./Auth/AuthProvider.ts";
@@ -20,7 +21,6 @@ import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
-import type { ActionLike } from "./Action.ts";
 import type { State } from "./State/State.ts";
 import { loadConfigProvider } from "./Util/ConfigProvider.ts";
 import { effectClass, taggedFunction } from "./Util/effect.ts";
@@ -291,8 +291,8 @@ const alchemy = (overrides?: { dev?: boolean }) =>
       : AlchemyContextLive,
   );
 
-export const evalStack = <A, B, Err, Req>(
-  effect: StackEffect<CompiledStack<A>, Stage | AlchemyContext>,
+export const evalStack = <A, B, StackErr, Err, Req>(
+  effect: StackEffect<CompiledStack<A>, StackErr, Stage | AlchemyContext>,
   fn: (stack: CompiledStack<A>) => Effect.Effect<B, Err, Req>,
   options: {
     stage: string;

package/src/State/StateEncoding.ts

@@ -1,3 +1,4 @@
+import * as Duration from "effect/Duration";
 import * as Redacted from "effect/Redacted";
 import { isResource } from "../Resource.ts";
 
@@ -8,6 +9,40 @@ import { isResource } from "../Resource.ts";
  */
 export const REDACTED_MARKER = "__redacted__";
 
+/**
+ * JSON marker used to tag a `Duration` value when writing state.
+ * The reviver recognises objects with exactly this key and rebuilds
+ * a real `Duration` instance on read so that downstream code can call
+ * `Duration.toSeconds`, `Duration.toMillis`, etc. without first
+ * decoding `Duration.toJSON`'s `{_id,_tag,...}` shape.
+ */
+export const DURATION_MARKER = "__duration__";
+
+const decodeDuration = (encoded: unknown): Duration.Duration | undefined => {
+  if (encoded === null || typeof encoded !== "object") return undefined;
+  const json = encoded as {
+    _tag?: "Millis" | "Nanos" | "Infinity" | "NegativeInfinity";
+    millis?: number;
+    nanos?: string;
+  };
+  switch (json._tag) {
+    case "Millis":
+      return json.millis !== undefined
+        ? Duration.millis(json.millis)
+        : undefined;
+    case "Nanos":
+      return json.nanos !== undefined
+        ? Duration.nanos(BigInt(json.nanos))
+        : undefined;
+    case "Infinity":
+      return Duration.infinity;
+    case "NegativeInfinity":
+      return Duration.zero; // Effect treats negatives as zero clamp
+    default:
+      return undefined;
+  }
+};
+
 /**
  * Recursively encode a state value for JSON serialisation.
  *
@@ -32,6 +67,16 @@ export const encodeState = (value: unknown): unknown => {
       [REDACTED_MARKER]: encodeState(Redacted.value(value)),
     };
   }
+  if (Duration.isDuration(value)) {
+    // `JSON.stringify(Duration.seconds(N))` already invokes Duration.toJSON,
+    // but encodeState is also called for code paths that don't go through
+    // `JSON.stringify` (e.g. the HTTP state-store). Tag with our marker so
+    // the reviver can unambiguously rebuild a real Duration instance —
+    // Duration.toJSON's `{_id,_tag,...}` shape is NOT a valid Duration.Input.
+    return {
+      [DURATION_MARKER]: value.toJSON(),
+    };
+  }
   if (isResource(value)) {
     return {
       id: value.LogicalId,
@@ -56,13 +101,15 @@ export const encodeState = (value: unknown): unknown => {
  * through {@link encodeState}. Intended for use with `JSON.parse`.
  */
 export const reviveState = (_key: string, value: unknown): unknown => {
-  if (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    REDACTED_MARKER in value
-  ) {
-    return Redacted.make((value as Record<string, unknown>)[REDACTED_MARKER]);
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value as Record<string, unknown>;
+    if (REDACTED_MARKER in obj) {
+      return Redacted.make(obj[REDACTED_MARKER]);
+    }
+    if (DURATION_MARKER in obj) {
+      const decoded = decodeDuration(obj[DURATION_MARKER]);
+      if (decoded !== undefined) return decoded;
+    }
   }
   return value;
 };
@@ -82,6 +129,10 @@ export const reviveStateRecursive = (value: unknown): unknown => {
   if (keys.length === 1 && keys[0] === REDACTED_MARKER) {
     return Redacted.make(reviveStateRecursive(obj[REDACTED_MARKER]));
   }
+  if (keys.length === 1 && keys[0] === DURATION_MARKER) {
+    const decoded = decodeDuration(obj[DURATION_MARKER]);
+    if (decoded !== undefined) return decoded;
+  }
   const result: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(obj)) {
     result[k] = reviveStateRecursive(v);

package/src/Test/Bun.ts

@@ -7,11 +7,8 @@ import type { HookOptions } from "node:test";
 import type { AlchemyContext } from "../AlchemyContext.ts";
 import type { CompiledStack } from "../Stack.ts";
 import type { Stage } from "../Stage.ts";
-import { installLocalhostDns } from "../Util/LocalhostDns.ts";
 import * as Core from "./Core.ts";
 
-installLocalhostDns();
-
 export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
 export type ScratchStack = Core.ScratchStack;
 export type TestEffect<A, R = never> = Core.TestEffect<A, R>;

package/src/Test/Vitest.ts

@@ -12,11 +12,8 @@ import {
 import type { AlchemyContext } from "../AlchemyContext.ts";
 import type { CompiledStack } from "../Stack.ts";
 import type { Stage } from "../Stage.ts";
-import { installLocalhostDns } from "../Util/LocalhostDns.ts";
 import * as Core from "./Core.ts";
 
-installLocalhostDns();
-
 export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
 export type ScratchStack = Core.ScratchStack;
 export type TestEffect<A, R = never> = Core.TestEffect<A, R>;

package/src/Util/Duration.ts

@@ -0,0 +1,21 @@
+import * as Duration from "effect/Duration";
+
+/**
+ * Convert a {@link Duration.Input} to whole, non-negative
+ * milliseconds. Returns `undefined` when `input` is `undefined`,
+ * so call sites can map through optional duration fields without
+ * a branch.
+ */
+export const toMillis = (input: Duration.Input | undefined) =>
+  input === undefined
+    ? undefined
+    : Math.max(0, Math.ceil(Duration.toMillis(input)));
+
+/**
+ * Convert a {@link Duration.Input} to whole, non-negative seconds.
+ * Returns `undefined` when `input` is `undefined`.
+ */
+export const toSeconds = (input: Duration.Input | undefined) =>
+  input === undefined
+    ? undefined
+    : Math.max(0, Math.ceil(Duration.toSeconds(input)));

package/src/Util/PlatformServices.ts

@@ -12,6 +12,23 @@ import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
 
 const isBun = typeof Bun !== "undefined";
 
+/**
+ * Constructs a layer with different implementations for Bun and Node.
+ */
+export const platformLayer = <A, E, R>(constructors: {
+  bun: () => Promise<Layer.Layer<A, E, R>>;
+  node: () => Promise<Layer.Layer<A, E, R>>;
+}) =>
+  Layer.unwrap(
+    Effect.promise(async () => {
+      if (isBun) {
+        return await constructors.bun();
+      } else {
+        return await constructors.node();
+      }
+    }),
+  );
+
 export type PlatformServices =
   | ChildProcessSpawner
   | FileSystem
@@ -21,29 +38,25 @@ export type PlatformServices =
   // WebSocketConstructor is not included in NodeServices/BunServices, but required for Workers tail
   | WebSocketConstructor;
 
-export const PlatformServices: Layer.Layer<PlatformServices> = Effect.promise(
-  async () => {
-    if (isBun) {
-      const [BunServices, BunSocket] = await Promise.all([
-        import("@effect/platform-bun/BunServices"),
-        import("@effect/platform-bun/BunSocket"),
-      ]);
-      return Layer.merge(
-        BunServices.layer,
-        BunSocket.layerWebSocketConstructor,
-      );
-    } else {
-      const [NodeServices, NodeSocket] = await Promise.all([
-        import("@effect/platform-node/NodeServices"),
-        import("@effect/platform-node/NodeSocket"),
-      ]);
-      return Layer.merge(
-        NodeServices.layer,
-        NodeSocket.layerWebSocketConstructor,
-      );
-    }
+export const PlatformServices: Layer.Layer<PlatformServices> = platformLayer({
+  bun: async () => {
+    const [BunServices, BunSocket] = await Promise.all([
+      import("@effect/platform-bun/BunServices"),
+      import("@effect/platform-bun/BunSocket"),
+    ]);
+    return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
+  },
+  node: async () => {
+    const [NodeServices, NodeSocket] = await Promise.all([
+      import("@effect/platform-node/NodeServices"),
+      import("@effect/platform-node/NodeSocket"),
+    ]);
+    return Layer.merge(
+      NodeServices.layer,
+      NodeSocket.layerWebSocketConstructor,
+    );
   },
-).pipe(Layer.unwrap);
+});
 
 export const runMain = <E, A>(
   effect: Effect.Effect<A, E>,
@@ -67,15 +80,16 @@ export const httpServer = (
   port: number = 0,
   host: string = "127.0.0.1",
 ): Layer.Layer<HttpServer, ServeError> =>
-  Effect.promise(async () => {
-    if (isBun) {
+  platformLayer({
+    bun: async () => {
       const BunHttpServer = await import("@effect/platform-bun/BunHttpServer");
       return BunHttpServer.layer({ hostname: host, port });
-    } else {
+    },
+    node: async () => {
       const [NodeHttpServer, Http] = await Promise.all([
         import("@effect/platform-node/NodeHttpServer"),
         import("node:http"),
       ]);
       return NodeHttpServer.layerServer(Http.createServer, { host, port });
-    }
-  }).pipe(Layer.unwrap);
+    },
+  });

package/src/Util/camel.ts

@@ -1,3 +1,5 @@
+import { isPlainObject } from "./data.ts";
+
 export const camelCaseKey = (key: string) =>
   key
     .replace(/^_+/, "")
@@ -7,11 +9,7 @@ export const toCamelCase = <T>(value: unknown): T => {
   if (Array.isArray(value)) {
     return value.map((item) => toCamelCase(item)) as T;
   }
-  if (
-    value &&
-    typeof value === "object" &&
-    Object.getPrototypeOf(value) === Object.prototype
-  ) {
+  if (isPlainObject(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([key, nested]) => [
         camelCaseKey(key),

package/src/Util/data.ts

@@ -1,3 +1,7 @@
+import * as Predicate from "effect/Predicate";
+import * as EffectRecord from "effect/Record";
+import * as Redacted from "effect/Redacted";
+
 export type Primitive =
   | never
   | undefined
@@ -16,3 +20,37 @@ export const isPrimitive = (value: any): value is Primitive =>
   typeof value === "string" ||
   typeof value === "symbol" ||
   typeof value === "bigint";
+
+export const isPlainObject = (
+  value: unknown,
+): value is Record<string, unknown> => {
+  if (!Predicate.isObject(value)) return false;
+  return Object.getPrototypeOf(value) === Object.prototype;
+};
+
+export const stripFields = <T>(value: T, empty: null | undefined): T => {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripFields(item, empty)) as T;
+  }
+  if (!isPlainObject(value)) return value;
+  return EffectRecord.map(
+    EffectRecord.filter(value, (entry) => entry !== empty),
+    (entry) => stripFields(entry, empty),
+  ) as T;
+};
+
+export const stripNullFields = <T>(value: T): T => stripFields(value, null);
+
+export const stripUndefinedFields = <T>(value: T): T =>
+  stripFields(value, undefined);
+
+export const unwrapRedacted = <T>(value: T): T => {
+  if (Redacted.isRedacted(value)) {
+    return Redacted.value(value) as T;
+  }
+  if (Array.isArray(value)) {
+    return value.map(unwrapRedacted) as T;
+  }
+  if (!isPlainObject(value)) return value;
+  return EffectRecord.map(value, unwrapRedacted) as T;
+};

package/src/Util/index.ts

@@ -1,16 +1,10 @@
-export * from "./assert-never.ts";
 export * from "./base32.ts";
 export * from "./camel.ts";
-export * from "./class.ts";
 export * from "./data.ts";
 export * from "./dedent.ts";
-export * from "./instance.ts";
-export * from "./pointer.ts";
-export * from "./schema-to-type.ts";
 export * from "./service.ts";
 export * from "./sha256.ts";
 export * from "./stable.ts";
-export * from "./todo.ts";
 export * from "./type.ts";
 export * from "./types.ts";
 export * from "./unknown.ts";