@evolu/common 4.1.0 → 5.0.0

package/dist/src/index.d.ts

@@ -2,18 +2,15 @@ export * from "./Config.js";
 export * from "./Crdt.js";
 export * from "./Crypto.js";
 export * from "./Db.js";
-export * from "./DbWorker.js";
 export * from "./Diff.js";
-export * from "./ErrorStore.js";
+export * from "./Error.js";
 export * from "./Evolu.js";
 export * from "./Model.js";
 export * from "./Murmurhash.js";
-export * from "./OnCompletes.js";
 export * from "./Owner.js";
 export * from "./Platform.js";
 export * from "./Protobuf.js";
-export * from "./Public.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./SyncWorker.js";
+export * from "./Sync.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/src/index.js

@@ -2,17 +2,14 @@ export * from "./Config.js";
 export * from "./Crdt.js";
 export * from "./Crypto.js";
 export * from "./Db.js";
-export * from "./DbWorker.js";
 export * from "./Diff.js";
-export * from "./ErrorStore.js";
+export * from "./Error.js";
 export * from "./Evolu.js";
 export * from "./Model.js";
 export * from "./Murmurhash.js";
-export * from "./OnCompletes.js";
 export * from "./Owner.js";
 export * from "./Platform.js";
 export * from "./Protobuf.js";
-export * from "./Public.js";
 export * from "./Sqlite.js";
 export * from "./Store.js";
-export * from "./SyncWorker.js";
+export * from "./Sync.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evolu/common",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "description": "Local-first platform designed for privacy, ease of use, and no vendor lock-in to sync and backup people's lifetime data",
   "keywords": [
     "evolu",
@@ -44,28 +44,30 @@
     "README.md"
   ],
   "dependencies": {
-    "@noble/ciphers": "^0.5.1",
+    "@noble/ciphers": "^0.5.2",
     "@noble/hashes": "^1.4.0",
     "@protobuf-ts/runtime": "^2.9.4",
-    "@scure/bip39": "^1.2.2",
+    "@scure/bip39": "^1.3.0",
     "kysely": "^0.27.3",
-    "nanoid": "^5.0.6"
+    "nanoid": "^5.0.7"
   },
   "devDependencies": {
-    "@effect/schema": "^0.64.9",
+    "@effect/platform": "^0.50.7",
+    "@effect/schema": "^0.66.10",
     "@protobuf-ts/plugin": "^2.9.4",
     "@protobuf-ts/protoc": "^2.9.4",
     "array-shuffle": "^3.0.0",
-    "effect": "2.4.9",
+    "effect": "^3.0.7",
     "eslint": "^8.57.0",
-    "typescript": "^5.4.3",
-    "vitest": "^1.4.0",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.2",
     "@evolu/tsconfig": "0.0.2",
     "eslint-config-evolu": "1.0.0"
   },
   "peerDependencies": {
-    "@effect/schema": "^0.64.9",
-    "effect": "2.4.9"
+    "@effect/platform": "^0.50.2",
+    "@effect/schema": "^0.64.20",
+    "effect": "^3.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Config.ts

@@ -1,60 +1,103 @@
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
-import { CreateIndexBuilder } from "kysely";
+import * as LogLevel from "effect/LogLevel";
+import * as Logger from "effect/Logger";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as Match from "effect/Match";
 
 export interface Config {
-  /** Alternate URL to Evolu sync and backup server. */
-  readonly syncUrl: string;
-
   /**
-   * Alternate URL to reload browser tabs after {@link Owner} reset or restore.
+   * URL to reload browser tabs after {@link Owner} reset or restore.
+   *
    * The default value is `/`.
    */
-  readonly reloadUrl: string;
+  reloadUrl: string;
 
   /**
-   * Maximum physical clock drift allowed in ms. The default value is 5 * 60 *
-   * 1000 (5 minutes).
+   * URL for Evolu sync and backup server.
+   *
+   * The default value is `https://evolu.world`.
    */
-  readonly maxDrift: number;
+  syncUrl: string;
 
   /**
-   * Evolu application name. For now, this is only useful for localhost
-   * development, where we want each application to have its own database. The
-   * default value is: "Evolu".
+   * Evolu is multitenant - it can run more instances concurrently. Every Evolu
+   * instance has to have its own unique name. Database files are separated and
+   * invisible to each other.
+   *
+   * The default value is: `Evolu`.
    */
-  readonly name: string;
+  name: string;
 
   /**
-   * Use the `indexes` property to define SQLite indexes.
-   *
-   * Table and column names are not typed because Kysely doesn't support it.
+   * Maximum physical clock drift allowed in ms.
    *
-   * https://medium.com/@JasonWyatt/squeezing-performance-from-sqlite-indexes-indexes-c4e175f3c346
-   *
-   * @example
-   *   const indexes = [
-   *     createIndex("indexTodoCreatedAt").on("todo").column("createdAt"),
+   * The default value is 5 * 60 * 1000 (5 minutes).
+   */
+  maxDrift: number;
+
+  /**
+   * Setting the minimum log level. The default value is `none`.
    *
-   *     createIndex("indexTodoCategoryCreatedAt")
-   *       .on("todoCategory")
-   *       .column("createdAt"),
-   *   ];
+   * For development, use `trace` to log all events and `debug` to log only
+   * events with values. For production, use `warning`.
    */
-  readonly indexes: ReadonlyArray<CreateIndexBuilder<any>>;
+  minimumLogLevel: "none" | "trace" | "debug" | "warning";
 }
 
-export const Config = Context.GenericTag<Config>("@services/Config");
-
-export const ConfigLive = (config?: Partial<Config>): Layer.Layer<Config> =>
-  Layer.succeed(
-    Config,
-    Config.of({
-      syncUrl: "https://evolu.world",
-      maxDrift: 5 * 60 * 1000,
-      reloadUrl: "/",
-      name: "Evolu",
-      indexes: [],
-      ...config,
-    }),
+export const Config = Context.GenericTag<Config>("Config");
+
+export const defaultConfig: Config = {
+  reloadUrl: "/",
+  syncUrl: "https://evolu.world",
+  name: "Evolu",
+  maxDrift: 5 * 60 * 1000,
+  minimumLogLevel: "none",
+};
+
+/** https://effect.website/docs/guides/runtime */
+export const createRuntime = (
+  partialConfig?: Partial<Config>,
+): ManagedRuntime.ManagedRuntime<Config, never> => {
+  const config = { ...defaultConfig, ...partialConfig };
+  const ConfigLive = Layer.succeed(Config, config);
+
+  const minimumLogLevel = Match.value(config.minimumLogLevel).pipe(
+    Match.when("debug", () => LogLevel.Debug),
+    Match.when("none", () => LogLevel.None),
+    Match.when("trace", () => LogLevel.Trace),
+    Match.when("warning", () => LogLevel.Warning),
+    Match.exhaustive,
   );
+
+  const evoluLayer =
+    config.minimumLogLevel === "none"
+      ? ConfigLive
+      : Layer.mergeAll(
+          ConfigLive,
+          Logger.minimumLogLevel(minimumLogLevel),
+          Logger.replace(Logger.defaultLogger, makeEvoluLogger(config.name)),
+        );
+
+  return ManagedRuntime.make(evoluLayer);
+};
+
+// TODO: Spans and Effect native variadic log args.
+const makeEvoluLogger = (name: string) =>
+  Logger.make(({ logLevel, message, date }) => {
+    const fn =
+      logLevel._tag === "Warning"
+        ? "warn"
+        : logLevel._tag === "Error"
+          ? "error"
+          : "log";
+
+    const hours = date.getHours().toString().padStart(2, "0");
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    const seconds = date.getSeconds().toString().padStart(2, "0");
+    const milliseconds = date.getMilliseconds().toString().padStart(3, "0");
+    const formattedDate = `${hours}:${minutes}:${seconds}:${milliseconds}`;
+
+    const messages: unknown[] = Array.isArray(message) ? message : [message];
+    globalThis.console[fn](`${formattedDate} [${name}]`, ...messages);
+  });

package/src/Crdt.ts

@@ -1,4 +1,5 @@
 import * as S from "@effect/schema/Schema";
+import * as Arr from "effect/Array";
 import * as Brand from "effect/Brand";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -7,7 +8,6 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Number from "effect/Number";
 import * as Option from "effect/Option";
-import * as ReadonlyArray from "effect/ReadonlyArray";
 import * as String from "effect/String";
 import { Config } from "./Config.js";
 import { NanoIdGenerator, NodeId } from "./Crypto.js";
@@ -36,7 +36,7 @@ export const AllowedTimeRange = {
  * the device clock is out of range, Evolu will not store data until it's
  * fixed.
  */
-export const Millis = S.number.pipe(
+export const Millis = S.Number.pipe(
   S.greaterThan(AllowedTimeRange.greaterThan),
   S.lessThan(AllowedTimeRange.lessThan),
   S.brand("Millis"),
@@ -48,7 +48,7 @@ export const initialMillis = S.decodeSync(Millis)(
   AllowedTimeRange.greaterThan + 1,
 );
 
-export const Counter = S.number.pipe(S.between(0, 65535), S.brand("Counter"));
+export const Counter = S.Number.pipe(S.between(0, 65535), S.brand("Counter"));
 export type Counter = S.Schema.Type<typeof Counter>;
 
 const initialCounter = S.decodeSync(Counter)(0);
@@ -87,7 +87,7 @@ export const makeSyncTimestamp = (
 });
 
 export const makeInitialTimestamp = NanoIdGenerator.pipe(
-  Effect.flatMap(({ nanoidAsNodeId }) => nanoidAsNodeId),
+  Effect.flatMap(({ nodeId }) => nodeId),
   Effect.map(
     (node): Timestamp => ({
       millis: initialMillis,
@@ -97,15 +97,13 @@ export const makeInitialTimestamp = NanoIdGenerator.pipe(
   ),
 );
 
-export interface Time {
-  readonly now: Effect.Effect<Millis, TimestampTimeOutOfRangeError>;
-}
-
-export const Time = Context.GenericTag<Time>("@services/Time");
-
-export const TimeLive = Layer.succeed(
+export class Time extends Context.Tag("Time")<
   Time,
-  Time.of({
+  {
+    readonly now: Effect.Effect<Millis, TimestampTimeOutOfRangeError>;
+  }
+>() {
+  static Live = Layer.succeed(Time, {
     now: Effect.suspend(() => S.decode(Millis)(Date.now())).pipe(
       Effect.catchTag("ParseError", () =>
         Effect.fail<TimestampTimeOutOfRangeError>({
@@ -113,8 +111,8 @@ export const TimeLive = Layer.succeed(
         }),
       ),
     ),
-  }),
-);
+  });
+}
 
 /**
  * The TimestampError type represents all Timestamp-related errors. If such an
@@ -146,39 +144,33 @@ export interface TimestampTimeOutOfRangeError {
   readonly _tag: "TimestampTimeOutOfRangeError";
 }
 
-const getNextMillis = (
-  millis: ReadonlyArray<Millis>,
-): Effect.Effect<
-  Millis,
-  TimestampDriftError | TimestampTimeOutOfRangeError,
-  Time | Config
-> =>
-  Effect.gen(function* (_) {
-    const time = yield* _(Time);
-    const config = yield* _(Config);
+const getNextMillis = (millis: ReadonlyArray<Millis>) =>
+  Effect.gen(function* () {
+    const time = yield* Time;
+    const config = yield* Config;
 
-    const now = yield* _(time.now);
+    const now = yield* time.now;
     const next = Math.max(now, ...millis) as Millis;
 
     if (next - now > config.maxDrift)
-      yield* _(
-        Effect.fail<TimestampDriftError>({
-          _tag: "TimestampDriftError",
-          now,
-          next,
-        }),
-      );
+      yield* Effect.fail<TimestampDriftError>({
+        _tag: "TimestampDriftError",
+        now,
+        next,
+      });
 
     return next;
   });
 
-const incrementCounter = (
-  counter: Counter,
-): Either.Either<Counter, TimestampCounterOverflowError> =>
+const incrementCounter = (counter: Counter) =>
   pipe(
     Number.increment(counter),
     S.decodeEither(Counter),
-    Either.mapLeft(() => ({ _tag: "TimestampCounterOverflowError" })),
+    Either.mapLeft(
+      (): TimestampCounterOverflowError => ({
+        _tag: "TimestampCounterOverflowError",
+      }),
+    ),
   );
 
 const counterMin = S.decodeSync(Counter)(0);
@@ -192,11 +184,11 @@ export const sendTimestamp = (
   | TimestampTimeOutOfRangeError,
   Time | Config
 > =>
-  Effect.gen(function* (_) {
-    const millis = yield* _(getNextMillis([timestamp.millis]));
+  Effect.gen(function* () {
+    const millis = yield* getNextMillis([timestamp.millis]);
     const counter =
       millis === timestamp.millis
-        ? yield* _(incrementCounter(timestamp.counter))
+        ? yield* incrementCounter(timestamp.counter)
         : counterMin;
     return { ...timestamp, millis, counter };
   });
@@ -217,23 +209,19 @@ export const receiveTimestamp = ({
 > =>
   Effect.gen(function* (_) {
     if (local.node === remote.node)
-      yield* _(
-        Effect.fail<TimestampDuplicateNodeError>({
-          _tag: "TimestampDuplicateNodeError",
-          node: local.node,
-        }),
-      );
-
-    const millis = yield* _(getNextMillis([local.millis, remote.millis]));
-    const counter = yield* _(
-      millis === local.millis && millis === remote.millis
-        ? incrementCounter(Math.max(local.counter, remote.counter) as Counter)
-        : millis === local.millis
-          ? incrementCounter(local.counter)
-          : millis === remote.millis
-            ? incrementCounter(remote.counter)
-            : Either.right(counterMin),
-    );
+      yield* Effect.fail<TimestampDuplicateNodeError>({
+        _tag: "TimestampDuplicateNodeError",
+        node: local.node,
+      });
+
+    const millis = yield* getNextMillis([local.millis, remote.millis]);
+    const counter = yield* millis === local.millis && millis === remote.millis
+      ? incrementCounter(Math.max(local.counter, remote.counter) as Counter)
+      : millis === local.millis
+        ? incrementCounter(local.counter)
+        : millis === remote.millis
+          ? incrementCounter(remote.counter)
+          : Either.right(counterMin);
 
     return { ...local, millis, counter };
   });
@@ -262,17 +250,15 @@ export const millisToMerkleTreePath = (millis: Millis): MerkleTreePath =>
     .toString(3)
     .split("") as MerkleTreePath;
 
-const merkleTreePathToMillis = (path: MerkleTreePath): Millis =>
+const merkleTreePathToMillis = (path: MerkleTreePath) =>
   path.length === 0
     ? initialMillis
     : // 16 is the length of the base 3 value of the current time in minutes.
       // Ensure it's padded to create the full value.
       ((parseInt(path.join("").padEnd(16, "0"), 3) * 1000 * 60) as Millis);
 
-const xorTimestampHashes = (
-  a: TimestampHash | undefined,
-  b: TimestampHash,
-): TimestampHash => ((a || 0) ^ b) as TimestampHash;
+const xorTimestampHashes = (a: TimestampHash | undefined, b: TimestampHash) =>
+  ((a || 0) ^ b) as TimestampHash;
 
 const insertKey = (
   tree: MerkleTree,
@@ -292,23 +278,22 @@ const insertKey = (
   };
 };
 
-export const insertIntoMerkleTree =
-  (timestamp: Timestamp) =>
-  (tree: MerkleTree): MerkleTree => {
-    const path = millisToMerkleTreePath(timestamp.millis);
-    const hash = timestampToHash(timestamp);
-    return insertKey(
-      { ...tree, hash: xorTimestampHashes(tree.hash, hash) },
-      path,
-      hash,
-    );
-  };
+export const insertIntoMerkleTree = (
+  tree: MerkleTree,
+  timestamp: Timestamp,
+): MerkleTree => {
+  const path = millisToMerkleTreePath(timestamp.millis);
+  const hash = timestampToHash(timestamp);
+  return insertKey(
+    { ...tree, hash: xorTimestampHashes(tree.hash, hash) },
+    path,
+    hash,
+  );
+};
 
 const sortedMerkleTreeKeys: ReadonlyArray<MerkleTreeKey> = ["0", "1", "2"];
 
-const getSortedMerkleTreeKeys = (
-  tree: MerkleTree,
-): ReadonlyArray<MerkleTreeKey> =>
+const getSortedMerkleTreeKeys = (tree: MerkleTree) =>
   sortedMerkleTreeKeys.filter((key) => key in tree);
 
 export const diffMerkleTrees = (
@@ -326,7 +311,7 @@ export const diffMerkleTrees = (
   // the top of this function should pass)
   // eslint-disable-next-line no-constant-condition
   while (1) {
-    const keys = ReadonlyArray.dedupeWith(
+    const keys = Arr.dedupeWith(
       getSortedMerkleTreeKeys(node1).concat(getSortedMerkleTreeKeys(node2)),
       String.Equivalence,
     );

package/src/Crypto.ts

@@ -8,25 +8,40 @@ import * as Brand from "effect/Brand";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { customAlphabet, nanoid } from "nanoid";
 
-// TODO: Add dynamic import error.
-export interface Bip39 {
-  readonly make: Effect.Effect<Mnemonic>;
+import { Id } from "./Model.js";
 
-  readonly toSeed: (mnemonic: Mnemonic) => Effect.Effect<Uint8Array>;
+export class Bip39 extends Context.Tag("Bip39")<
+  Bip39,
+  {
+    readonly make: Effect.Effect<Mnemonic>;
 
-  readonly parse: (
-    mnemonic: string,
-  ) => Effect.Effect<Mnemonic, InvalidMnemonicError>;
-}
+    readonly toSeed: (mnemonic: Mnemonic) => Effect.Effect<Uint8Array>;
 
-export const Bip39 = Context.GenericTag<Bip39>("@services/Bip39");
+    readonly parse: (
+      mnemonic: string,
+    ) => Effect.Effect<Mnemonic, InvalidMnemonicError>;
+  }
+>() {}
 
 export interface InvalidMnemonicError {
   readonly _tag: "InvalidMnemonicError";
 }
 
+export const validateMnemonicToEffect =
+  (validateMnemonic: (mnemonic: string, wordlist: string[]) => boolean) =>
+  (
+    mnemonic: string,
+    wordlist: string[],
+  ): Effect.Effect<Mnemonic, InvalidMnemonicError, never> => {
+    const mnemonicTrimmed = mnemonic.trim();
+    return validateMnemonic(mnemonicTrimmed, wordlist)
+      ? Effect.succeed(mnemonicTrimmed as Mnemonic)
+      : Effect.fail<InvalidMnemonicError>({
+          _tag: "InvalidMnemonicError",
+        });
+  };
+
 /**
  * Mnemonic is a password generated by Evolu in BIP39 format.
  *
@@ -36,33 +51,41 @@ export interface InvalidMnemonicError {
  */
 export type Mnemonic = string & Brand.Brand<"Mnemonic">;
 
-export interface NanoIdGenerator {
-  readonly nanoid: Effect.Effect<NanoId>;
-  readonly nanoidAsNodeId: Effect.Effect<NodeId>;
-}
-
-export const NanoIdGenerator = Context.GenericTag<NanoIdGenerator>(
-  "@services/NanoIdGenerator",
-);
+export class NanoIdGenerator extends Context.Tag("NanoIdGenerator")<
+  NanoIdGenerator,
+  {
+    readonly nanoid: Effect.Effect<NanoId>;
+    readonly nodeId: Effect.Effect<NodeId>;
+    readonly rowId: Effect.Effect<Id>;
+  }
+>() {}
+
+export const createNanoIdGeneratorLive = (
+  customAlphabet: (
+    alphabet: string,
+    defaultSize?: number | undefined,
+  ) => (size?: number | undefined) => string,
+  nanoid: (size?: number) => string,
+): Layer.Layer<NanoIdGenerator, never, never> => {
+  const nanoidForNodeId = customAlphabet("0123456789abcdef", 16);
+  return Layer.succeed(
+    NanoIdGenerator,
+    NanoIdGenerator.of({
+      nanoid: Effect.sync(() => nanoid() as NanoId),
+      nodeId: Effect.sync(() => nanoidForNodeId() as NodeId),
+      rowId: Effect.sync(() => nanoid() as Id),
+    }),
+  );
+};
 
 export type NanoId = string & Brand.Brand<"NanoId">;
 
-export const NodeId = S.string.pipe(
+export const NodeId = S.String.pipe(
   S.pattern(/^[\w-]{16}$/),
   S.brand("NodeId"),
 );
 export type NodeId = S.Schema.Type<typeof NodeId>;
 
-const nanoidForNodeId = customAlphabet("0123456789abcdef", 16);
-
-export const NanoIdGeneratorLive = Layer.succeed(
-  NanoIdGenerator,
-  NanoIdGenerator.of({
-    nanoid: Effect.sync(() => nanoid() as NanoId),
-    nanoidAsNodeId: Effect.sync(() => nanoidForNodeId() as NodeId),
-  }),
-);
-
 // SLIP-21 implementation
 // https://github.com/satoshilabs/slips/blob/master/slip-0021.md
 export const slip21Derive = (
@@ -81,35 +104,35 @@ export const slip21Derive = (
     return m.slice(32, 64);
   });
 
-/** Alias to xsalsa20poly1305, for compatibility with libsodium/nacl */
-export interface SecretBox {
-  readonly seal: (
-    key: Uint8Array,
-    plaintext: Uint8Array,
-  ) => Effect.Effect<Uint8Array>;
-
-  readonly open: (
-    key: Uint8Array,
-    ciphertext: Uint8Array,
-  ) => Effect.Effect<Uint8Array>;
-}
-
-export const SecretBox = Context.GenericTag<SecretBox>("@services/SecretBox");
-
-export const SecretBoxLive = Layer.succeed(
+export class SecretBox extends Context.Tag("SecretBox")<
   SecretBox,
-  SecretBox.of({
-    seal: (key, plaintext) =>
-      Effect.sync(() => {
-        const nonce = randomBytes(24);
-        const ciphertext = secretbox(key, nonce).seal(plaintext);
-        return concatBytes(nonce, ciphertext);
-      }),
-    open: (key, ciphertext) =>
-      Effect.sync(() => {
-        const nonce = ciphertext.subarray(0, 24);
-        const ciphertextWithoutNonce = ciphertext.subarray(24);
-        return secretbox(key, nonce).open(ciphertextWithoutNonce);
-      }),
-  }),
-);
+  {
+    readonly seal: (
+      key: Uint8Array,
+      plaintext: Uint8Array,
+    ) => Effect.Effect<Uint8Array>;
+
+    readonly open: (
+      key: Uint8Array,
+      ciphertext: Uint8Array,
+    ) => Effect.Effect<Uint8Array>;
+  }
+>() {
+  static Live = Layer.succeed(
+    SecretBox,
+    SecretBox.of({
+      seal: (key, plaintext) =>
+        Effect.sync(() => {
+          const nonce = randomBytes(24);
+          const ciphertext = secretbox(key, nonce).seal(plaintext);
+          return concatBytes(nonce, ciphertext);
+        }),
+      open: (key, ciphertext) =>
+        Effect.sync(() => {
+          const nonce = ciphertext.subarray(0, 24);
+          const ciphertextWithoutNonce = ciphertext.subarray(24);
+          return secretbox(key, nonce).open(ciphertextWithoutNonce);
+        }),
+    }),
+  );
+}