@evolu/common 1.0.0

package/dist/src/SyncWorker.js

@@ -0,0 +1,136 @@
+import { concatBytes } from "@noble/ciphers/utils";
+import { BinaryReader, BinaryWriter } from "@protobuf-ts/runtime";
+import { Context, Effect, Function, Layer, Match, Option, Predicate, ReadonlyArray, absurd, identity, } from "effect";
+import { SecretBox } from "./Crypto.js";
+import { makeUnexpectedError } from "./Errors.js";
+import { merkleTreeToString, unsafeMerkleTreeFromString, } from "./MerkleTree.js";
+import { Fetch, SyncLock } from "./Platform.js";
+import { MessageContent, SyncRequest, SyncResponse, } from "./Protobuf.js";
+export const SyncWorker = Context.Tag("evolu/SyncWorker");
+export const SyncWorkerPostMessage = Context.Tag("evolu/SyncWorkerPostMessage");
+const SyncWorkerOnMessage = Context.Tag("evolu/SyncWorkerOnMessage");
+const version1 = new Uint8Array([0, 1]);
+const valueToProtobuf = (value) => {
+    switch (typeof value) {
+        case "string":
+            return { oneofKind: "stringValue", stringValue: value };
+        case "number":
+            return { oneofKind: "numberValue", numberValue: value };
+    }
+    if (value == null)
+        return { oneofKind: undefined };
+    if (Predicate.isUint8Array(value))
+        return { oneofKind: "bytesValue", bytesValue: value };
+    return { oneofKind: "jsonValue", jsonValue: JSON.stringify(value) };
+};
+const valueFromProtobuf = (value) => {
+    switch (value.oneofKind) {
+        case "numberValue":
+            return value.numberValue;
+        case "stringValue":
+            return value.stringValue;
+        case "bytesValue":
+            return value.bytesValue;
+        case "jsonValue":
+            return JSON.parse(value.jsonValue);
+        case undefined:
+            return null;
+        default:
+            return absurd(value);
+    }
+};
+const newMessageToBinary = ({ value, ...rest }) => concatBytes(version1, MessageContent.toBinary({ value: valueToProtobuf(value), ...rest }, binaryWriteOptions));
+const startsWithArray = (array, prefix) => {
+    if (prefix.length > array.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (array[i] !== prefix[i])
+            return false;
+    }
+    return true;
+};
+const newMessageFromBinary = (binary) => {
+    if (!startsWithArray(binary, version1))
+        return Option.none();
+    const { value, ...content } = MessageContent.fromBinary(binary.slice(version1.length), binaryReadOptions);
+    return Option.some({ value: valueFromProtobuf(value), ...content });
+};
+// The 'protobuf-ts' uses TextEncoder, but polyfill fast-text-encoding
+// doesn't support the fatal option.
+// https://github.com/timostamm/protobuf-ts/issues/184#issuecomment-1658443836
+const binaryWriteOptions = {
+    writerFactory: () => new BinaryWriter({
+        encode: (input) => new TextEncoder().encode(input),
+    }),
+};
+const binaryReadOptions = {
+    readerFactory: (bytes) => new BinaryReader(bytes, {
+        decode: (input) => new TextDecoder().decode(input),
+    }),
+};
+const sync = (input) => Effect.gen(function* (_) {
+    const syncLock = yield* _(SyncLock);
+    const syncWorkerOnMessage = yield* _(SyncWorkerOnMessage);
+    const fetch = yield* _(Fetch);
+    const secretBox = yield* _(SecretBox);
+    if (input.syncLoopCount === 0) {
+        if (!(yield* _(syncLock.acquire)))
+            return;
+        syncWorkerOnMessage({ _tag: "SyncStateIsSyncing" });
+    }
+    yield* _(Effect.forEach(input.messages, ({ timestamp, ...newMessage }) => secretBox
+        .seal(input.owner.encryptionKey, newMessageToBinary(newMessage))
+        .pipe(Effect.map((content) => ({ timestamp, content })))), Effect.map((messages) => SyncRequest.toBinary({
+        messages,
+        userId: input.owner.id,
+        nodeId: input.timestamp.node,
+        merkleTree: merkleTreeToString(input.merkleTree),
+    }, binaryWriteOptions)), Effect.flatMap((body) => fetch(input.syncUrl, body)), Effect.catchTag("FetchError", () => Effect.fail({
+        _tag: "SyncStateIsNotSyncedError",
+        error: { _tag: "NetworkError" },
+    })), Effect.flatMap((response) => {
+        switch (response.status) {
+            case 402:
+                return Effect.fail({
+                    _tag: "SyncStateIsNotSyncedError",
+                    error: { _tag: "PaymentRequiredError" },
+                });
+            case 200:
+                return Effect.promise(() => response
+                    .arrayBuffer()
+                    .then((buffer) => new Uint8Array(buffer))
+                    .then((array) => SyncResponse.fromBinary(array, binaryReadOptions)));
+            default:
+                return Effect.fail({
+                    _tag: "SyncStateIsNotSyncedError",
+                    error: { _tag: "ServerError", status: response.status },
+                });
+        }
+    }), Effect.flatMap((syncResponse) => Effect.forEach(syncResponse.messages, ({ timestamp, content }) => secretBox
+        .open(input.owner.encryptionKey, content)
+        .pipe(Effect.map(newMessageFromBinary), Effect.map(Option.map((newMessage) => ({ timestamp, ...newMessage }))))).pipe(Effect.map((messages) => ({
+        _tag: "SyncWorkerOutputSyncResponse",
+        messages: ReadonlyArray.filterMap(messages, identity),
+        merkleTree: unsafeMerkleTreeFromString(syncResponse.merkleTree),
+        syncLoopCount: input.syncLoopCount,
+    })))), Effect.tapError(() => syncLock.release), Effect.merge, Effect.map(syncWorkerOnMessage));
+});
+export const SyncWorkerLive = Layer.effect(SyncWorker, Effect.gen(function* (_) {
+    const syncLock = yield* _(SyncLock);
+    const fetch = yield* _(Fetch);
+    const secretBox = yield* _(SecretBox);
+    const onError = (error) => Effect.sync(() => {
+        syncWorker.onMessage(error);
+    });
+    const postMessage = (input) => {
+        void Match.value(input).pipe(Match.tagsExhaustive({
+            sync,
+            syncCompleted: () => syncLock.release,
+        }), Effect.catchAllDefect(makeUnexpectedError), Effect.catchAll(onError), Effect.provideService(SyncLock, syncLock), Effect.provideService(Fetch, fetch), Effect.provideService(SecretBox, secretBox), Effect.provideService(SyncWorkerOnMessage, syncWorker.onMessage), Effect.runPromise);
+    };
+    const syncWorker = {
+        postMessage,
+        onMessage: Function.constVoid,
+    };
+    return syncWorker;
+}));

package/dist/src/Timestamp.d.ts

@@ -0,0 +1,44 @@
+import * as Schema from "@effect/schema/Schema";
+import { Brand, Context, Effect, Layer } from "effect";
+import { Config } from "./Config.js";
+import { NanoId, NodeId } from "./Crypto.js";
+export interface Timestamp {
+    readonly node: NodeId;
+    readonly millis: Millis;
+    readonly counter: Counter;
+}
+export declare const Millis: Schema.BrandSchema<number, number & Brand.Brand<"Millis">>;
+export type Millis = Schema.Schema.To<typeof Millis>;
+export declare const Counter: Schema.BrandSchema<number, number & Brand.Brand<"Counter">>;
+export type Counter = Schema.Schema.To<typeof Counter>;
+export type TimestampHash = number & Brand.Brand<"TimestampHash">;
+export type TimestampString = string & Brand.Brand<"TimestampString">;
+export declare const timestampToString: (t: Timestamp) => TimestampString;
+export declare const unsafeTimestampFromString: (s: TimestampString) => Timestamp;
+export declare const timestampToHash: (t: Timestamp) => TimestampHash;
+export declare const makeSyncTimestamp: (millis?: Millis) => Timestamp;
+export declare const makeInitialTimestamp: Effect.Effect<NanoId, never, Timestamp>;
+export interface Time {
+    readonly now: Effect.Effect<never, never, Millis>;
+}
+export declare const Time: Context.Tag<Time, Time>;
+export declare const TimeLive: Layer.Layer<never, never, Time>;
+export type TimestampError = TimestampDriftError | TimestampCounterOverflowError | TimestampDuplicateNodeError;
+export interface TimestampDriftError {
+    readonly _tag: "TimestampDriftError";
+    readonly next: Millis;
+    readonly now: Millis;
+}
+export interface TimestampCounterOverflowError {
+    readonly _tag: "TimestampCounterOverflowError";
+}
+export declare const sendTimestamp: (timestamp: Timestamp) => Effect.Effect<Time | Config, TimestampDriftError | TimestampCounterOverflowError, Timestamp>;
+export interface TimestampDuplicateNodeError {
+    readonly _tag: "TimestampDuplicateNodeError";
+    readonly node: NodeId;
+}
+export declare const receiveTimestamp: ({ local, remote, }: {
+    readonly local: Timestamp;
+    readonly remote: Timestamp;
+}) => Effect.Effect<Time | Config, TimestampDriftError | TimestampCounterOverflowError | TimestampDuplicateNodeError, Timestamp>;
+//# sourceMappingURL=Timestamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["../../src/Timestamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAU,KAAK,EAAgB,MAAM,QAAQ,CAAC;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAM7C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,MAAM,4DAGlB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,MAAM,CAAC,CAAC;AAIrD,eAAO,MAAM,OAAO,6DAGnB,CAAC;AACF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,OAAO,CAAC,CAAC;AAIvD,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;AAEtE,eAAO,MAAM,iBAAiB,MAAO,SAAS,KAAG,eAKjB,CAAC;AAEjC,eAAO,MAAM,yBAAyB,MAAO,eAAe,KAAG,SAO9D,CAAC;AAEF,eAAO,MAAM,eAAe,MAAO,SAAS,KAAG,aACI,CAAC;AAIpD,eAAO,MAAM,iBAAiB,YACpB,MAAM,KACb,SAID,CAAC;AAEH,eAAO,MAAM,oBAAoB,yCAShC,CAAC;AAEF,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;CACnD;AAED,eAAO,MAAM,IAAI,yBAAkC,CAAC;AAEpD,eAAO,MAAM,QAAQ,iCAKpB,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,mBAAmB,GACnB,6BAA6B,GAC7B,2BAA2B,CAAC;AAEhC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,IAAI,EAAE,+BAA+B,CAAC;CAChD;AAmCD,eAAO,MAAM,aAAa,cACb,SAAS,KACnB,aAAa,CACd,IAAI,GAAG,MAAM,EACb,mBAAmB,GAAG,6BAA6B,EACnD,SAAS,CASP,CAAC;AAEL,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,IAAI,EAAE,6BAA6B,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,gBAAgB;oBAIX,SAAS;qBACR,SAAS;MACxB,aAAa,CACf,IAAI,GAAG,MAAM,EACX,mBAAmB,GACnB,6BAA6B,GAC7B,2BAA2B,EAC7B,SAAS,CAuBP,CAAC"}

package/dist/src/Timestamp.js

@@ -0,0 +1,76 @@
+import * as Schema from "@effect/schema/Schema";
+import { Context, Effect, Either, Layer, Number, pipe } from "effect";
+import { Config } from "./Config.js";
+import { NanoId, NodeId } from "./Crypto.js";
+import { murmurhash } from "./Murmurhash.js";
+export const Millis = Schema.number.pipe(Schema.greaterThanOrEqualTo(0), Schema.brand("Millis"));
+const initialMillis = Schema.parseSync(Millis)(0);
+export const Counter = Schema.number.pipe(Schema.between(0, 65535), Schema.brand("Counter"));
+const initialCounter = Schema.parseSync(Counter)(0);
+export const timestampToString = (t) => [
+    new Date(t.millis).toISOString(),
+    t.counter.toString(16).toUpperCase().padStart(4, "0"),
+    t.node,
+].join("-");
+export const unsafeTimestampFromString = (s) => {
+    const a = s.split("-");
+    return {
+        millis: Date.parse(a.slice(0, 3).join("-")).valueOf(),
+        counter: parseInt(a[3], 16),
+        node: a[4],
+    };
+};
+export const timestampToHash = (t) => murmurhash(timestampToString(t));
+const syncNodeId = Schema.parseSync(NodeId)("0000000000000000");
+export const makeSyncTimestamp = (millis = initialMillis) => ({
+    millis,
+    counter: initialCounter,
+    node: syncNodeId,
+});
+export const makeInitialTimestamp = NanoId.pipe(Effect.flatMap(({ nanoidAsNodeId }) => nanoidAsNodeId), Effect.map((node) => ({
+    millis: initialMillis,
+    counter: initialCounter,
+    node,
+})));
+export const Time = Context.Tag("evolu/Time");
+export const TimeLive = Layer.succeed(Time, Time.of({
+    now: Effect.sync(() => Date.now()),
+}));
+const getNextMillis = (millis) => Effect.gen(function* (_) {
+    const time = yield* _(Time);
+    const config = yield* _(Config);
+    const now = yield* _(time.now);
+    const next = Math.max(now, ...millis);
+    if (next - now > config.maxDrift)
+        yield* _(Effect.fail({
+            _tag: "TimestampDriftError",
+            now,
+            next,
+        }));
+    return next;
+});
+const incrementCounter = (counter) => pipe(Number.increment(counter), Schema.parseEither(Counter), Either.mapLeft(() => ({ _tag: "TimestampCounterOverflowError" })));
+const counterMin = Schema.parseSync(Counter)(0);
+export const sendTimestamp = (timestamp) => Effect.gen(function* (_) {
+    const millis = yield* _(getNextMillis([timestamp.millis]));
+    const counter = millis === timestamp.millis
+        ? yield* _(incrementCounter(timestamp.counter))
+        : counterMin;
+    return { ...timestamp, millis, counter };
+});
+export const receiveTimestamp = ({ local, remote, }) => Effect.gen(function* (_) {
+    if (local.node === remote.node)
+        yield* _(Effect.fail({
+            _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))
+        : millis === local.millis
+            ? incrementCounter(local.counter)
+            : millis === remote.millis
+                ? incrementCounter(remote.counter)
+                : Either.right(counterMin));
+    return { ...local, millis, counter };
+});

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
+export * from "./Config.js";
+export * from "./Crypto.js";
+export * from "./Db.js";
+export * from "./DbWorker.js";
+export * from "./Diff.js";
+export * from "./Errors.js";
+export * from "./Evolu.js";
+export * from "./MerkleTree.js";
+export * from "./Model.js";
+export * from "./Murmurhash.js";
+export * from "./Platform.js";
+export * from "./Protobuf.js";
+export * from "./Sql.js";
+export * from "./Sqlite.js";
+export * from "./Store.js";
+export * from "./SyncWorker.js";
+export * from "./Timestamp.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,18 @@
+export { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/sqlite";
+export * from "./Config.js";
+export * from "./Crypto.js";
+export * from "./Db.js";
+export * from "./DbWorker.js";
+export * from "./Diff.js";
+export * from "./Errors.js";
+export * from "./Evolu.js";
+export * from "./MerkleTree.js";
+export * from "./Model.js";
+export * from "./Murmurhash.js";
+export * from "./Platform.js";
+export * from "./Protobuf.js";
+export * from "./Sql.js";
+export * from "./Sqlite.js";
+export * from "./Store.js";
+export * from "./SyncWorker.js";
+export * from "./Timestamp.js";

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@evolu/common",
+  "version": "1.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",
+    "local-first",
+    "sqlite",
+    "crdt",
+    "e2ee"
+  ],
+  "author": "Daniel Steigerwald <daniel@steigerwald.cz>",
+  "license": "MIT",
+  "repository": "evoluhq/evolu",
+  "bugs": {
+    "url": "https://github.com/evoluhq/evolu/issues"
+  },
+  "homepage": "https://evolu.dev",
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "browser": "./dist/src/index.js"
+    }
+  },
+  "react-native": {
+    "./index.js": "./dist/src/index.js"
+  },
+  "files": [
+    "dist/src/**",
+    "src/**",
+    "README.md"
+  ],
+  "dependencies": {
+    "@noble/ciphers": "^0.3.0",
+    "@noble/hashes": "^1.3.2",
+    "@protobuf-ts/runtime": "^2.9.1",
+    "@scure/bip39": "^1.2.1",
+    "kysely": "^0.26.3",
+    "nanoid": "^5.0.1"
+  },
+  "devDependencies": {
+    "@effect/schema": "^0.37.1",
+    "@protobuf-ts/plugin": "^2.9.1",
+    "@protobuf-ts/protoc": "^2.9.1",
+    "array-shuffle": "^3.0.0",
+    "effect": "2.0.0-next.36",
+    "eslint": "^8.50.0",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.5",
+    "@evolu/tsconfig": "0.0.2",
+    "eslint-config-evolu": "0.0.2"
+  },
+  "peerDependencies": {
+    "@effect/schema": "^0.37.1",
+    "effect": "2.0.0-next.36"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.16"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "rm -rf dist ./README.md && tsc && cp ../../README.md ./",
+    "lint": "TIMING=1 eslint src --ext .ts,.tsx",
+    "test": "vitest run",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "format": "prettier --write \"src/*.{ts,tsx,md}\"",
+    "protobuf": "pnpm protoc --ts_out ./src --proto_path protobuf protobuf/Protobuf.proto --ts_opt eslint_disable --ts_opt optimize_code_size && pnpm format"
+  }
+}

package/src/Config.ts

@@ -0,0 +1,33 @@
+import { Context, Layer } from "effect";
+
+export interface Config {
+  /**
+   * Alternate URL to Evolu sync&backup server.
+   */
+  readonly syncUrl: string;
+  /**
+   * Alternate URL to reload browser tabs after `Owner` reset or restore.
+   * The default value is `/`.
+   */
+  readonly reloadUrl: string;
+  /**
+   * Maximum physical clock drift allowed in ms.
+   * The default value is 5 * 60 * 1000 (5 minutes).
+   */
+  readonly maxDrift: number;
+}
+
+export const Config = Context.Tag<Config>("evolu/Config");
+
+export const ConfigLive = (
+  config?: Partial<Config>,
+): Layer.Layer<never, never, Config> =>
+  Layer.succeed(
+    Config,
+    Config.of({
+      syncUrl: "https://evolu.world",
+      maxDrift: 5 * 60 * 1000,
+      reloadUrl: "/",
+      ...config,
+    }),
+  );

package/src/Crypto.ts

@@ -0,0 +1,113 @@
+import * as Schema from "@effect/schema/Schema";
+import { secretbox } from "@noble/ciphers/salsa";
+import { concatBytes } from "@noble/ciphers/utils";
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+import { randomBytes } from "@noble/hashes/utils";
+import { Brand, Context, Effect, Layer } from "effect";
+import { customAlphabet, nanoid } from "nanoid";
+
+export interface Bip39 {
+  readonly make: Effect.Effect<never, never, Mnemonic>;
+
+  readonly toSeed: (
+    mnemonic: Mnemonic,
+  ) => Effect.Effect<never, never, Uint8Array>;
+
+  readonly parse: (
+    mnemonic: string,
+  ) => Effect.Effect<never, InvalidMnemonicError, Mnemonic>;
+}
+
+export const Bip39 = Context.Tag<Bip39>("evolu/Bip39");
+
+export interface InvalidMnemonicError {
+  readonly _tag: "InvalidMnemonicError";
+}
+
+/**
+ * Mnemonic is a password generated by Evolu in BIP39 format.
+ *
+ * A mnemonic, also known as a "seed phrase," is a set of 12 words in a
+ * specific order chosen from a predefined list. The purpose of the BIP39
+ * mnemonic is to provide a human-readable way of storing a private key.
+ */
+export type Mnemonic = string & Brand.Brand<"Mnemonic">;
+
+export interface NanoId {
+  readonly nanoid: Effect.Effect<never, never, string>;
+  readonly nanoidAsNodeId: Effect.Effect<never, never, NodeId>;
+}
+
+export const NanoId = Context.Tag<NanoId>("evolu/NanoId");
+
+export const NodeId: Schema.BrandSchema<
+  string,
+  string & Brand.Brand<"NodeId">
+> = Schema.string.pipe(Schema.pattern(/^[\w-]{16}$/), Schema.brand("NodeId"));
+export type NodeId = Schema.Schema.To<typeof NodeId>;
+
+const nanoidForNodeId = customAlphabet("0123456789abcdef", 16);
+
+export const NanoIdLive = Layer.succeed(
+  NanoId,
+  NanoId.of({
+    nanoid: Effect.sync(() => nanoid()),
+    nanoidAsNodeId: Effect.sync(() => nanoidForNodeId() as NodeId),
+  }),
+);
+
+/**
+ * SLIP-21 implementation
+ * https://github.com/satoshilabs/slips/blob/master/slip-0021.md
+ */
+export const slip21Derive = (
+  seed: Uint8Array,
+  path: string[],
+): Effect.Effect<never, never, Uint8Array> =>
+  Effect.sync(() => {
+    let m = hmac(sha512, "Symmetric key seed", seed);
+    for (let i = 0; i < path.length; i++) {
+      const p = new TextEncoder().encode(path[i]);
+      const e = new Uint8Array(p.byteLength + 1);
+      e[0] = 0;
+      e.set(p, 1);
+      m = hmac(sha512, m.slice(0, 32), e);
+    }
+    return m.slice(32, 64);
+  });
+
+/**
+ * Alias to xsalsa20poly1305, for compatibility with libsodium / nacl
+ */
+export interface SecretBox {
+  readonly seal: (
+    key: Uint8Array,
+    plaintext: Uint8Array,
+  ) => Effect.Effect<never, never, Uint8Array>;
+
+  readonly open: (
+    key: Uint8Array,
+    ciphertext: Uint8Array,
+  ) => Effect.Effect<never, never, Uint8Array>;
+}
+
+export const SecretBox = Context.Tag<SecretBox>("evolu/SecretBox");
+
+export const SecretBoxLive = 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);
+      }),
+  }),
+);