@evolu/common 8.15.1 → 8.17.0

package/src/Task.ts

@@ -2136,20 +2136,21 @@ export type RunDefaultDeps = ConsoleDep &
 /**
  * Creates {@link RunDefaultDeps}.
  *
+ * The leak detector reports to the provided console, or to a default one.
+ *
  * @group Run
  */
-export const createRunDefaultDeps = (): RunDefaultDeps => {
-  const console = createConsole();
-  return {
-    console,
-    leakDetector: isDev ? createLeakDetector({ console }) : noopLeakDetector,
-    nativeFetch: globalThis.fetch.bind(globalThis),
-    randomBytes: createRandomBytes(),
-    random: createRandom(),
-    reportDefect: reportDefectAfterMicrotask,
-    time: createTime(),
-  };
-};
+export const createRunDefaultDeps = ({
+  console = createConsole(),
+}: Partial<ConsoleDep> = {}): RunDefaultDeps => ({
+  console,
+  leakDetector: isDev ? createLeakDetector({ console }) : noopLeakDetector,
+  nativeFetch: globalThis.fetch.bind(globalThis),
+  randomBytes: createRandomBytes(),
+  random: createRandom(),
+  reportDefect: reportDefectAfterMicrotask,
+  time: createTime(),
+});
 
 /**
  * Factory type for creating root {@link DisposableRun} instances.
@@ -2198,7 +2199,7 @@ export const createRun: CreateRun = <D extends object>(
   deps?: RunCustomDeps<D>,
 ): DisposableRun<D> =>
   createRunInternal<D>({
-    ...createRunDefaultDeps(),
+    ...createRunDefaultDeps(deps),
     ...deps,
   } as RunDefaultDeps & D);
 
@@ -2406,8 +2407,11 @@ export function testCreateRun<D extends object>(
 export function testCreateRun<D extends object>(
   deps?: TestRunDefaultDeps | RunCustomDeps<D>,
 ): DisposableRun<TestRunDefaultDeps & D> {
+  // As in createRun, the default leak detector reports to a passed console.
+  const { console }: Partial<ConsoleDep> = deps ?? {};
   return createRunInternal<TestRunDefaultDeps & D>({
     ...testCreateDeps(),
+    ...(console && { leakDetector: testCreateLeakDetector({ console }) }),
     ...deps,
   } as TestRunDefaultDeps & D);
 }

package/src/Worker.ts

@@ -656,6 +656,9 @@ export const testCreateMessagePort: CreateMessagePort = <Input, Output = never>(
 /**
  * Creates an in-memory {@link BroadcastChannel} for testing.
  *
+ * Like a native channel, it structured-clones each message, so posting a value
+ * that cannot be cloned throws.
+ *
  * @group Testing
  */
 export const testCreateBroadcastChannel = <Input, Output = Input>(
@@ -667,7 +670,9 @@ export const testCreateBroadcastChannel = <Input, Output = Input>(
   const disposables = disposer.move();
 
   return {
-    postMessage: channel.postMessage,
+    postMessage: (message) => {
+      channel.postMessage(structuredClone(message));
+    },
     get onMessage() {
       return channel.onMessage;
     },

package/src/local-first/Db.ts

@@ -137,7 +137,10 @@ import type {
   EvoluInput,
   SharedWorkerId,
 } from "./Shared.ts";
-import { consoleEntryOrErrorBroadcastChannelName } from "./Shared.ts";
+import {
+  consoleEntryOrErrorBroadcastChannelName,
+  postConsoleEntry,
+} from "./Shared.ts";
 import {
   createBaseSqliteStorage,
   createBaseSqliteStorageTables,
@@ -229,6 +232,13 @@ export const startDbWorker =
         self.onMessage = (message) => resolve(ok(message));
       }),
     );
+    // Tabs report the errors this worker logs as an UnknownError, so it
+    // forwards them even for a silent app, whose tabs do not print them.
+    deps.console.setLevel(
+      initMessage.consoleLevel === "silent"
+        ? "error"
+        : initMessage.consoleLevel,
+    );
 
     const port = disposer.use(
       deps.createMessagePort<DbWorkerOutput, DbWorkerInput>(initMessage.port),
@@ -242,11 +252,7 @@ export const startDbWorker =
     disposer.defer(
       deps.consoleStoreOutputEntry.subscribe(() => {
         const entry = deps.consoleStoreOutputEntry.get();
-        if (entry)
-          consoleEntryOrErrorBroadcastChannel.postMessage({
-            type: "ConsoleEntry",
-            entry,
-          });
+        if (entry) postConsoleEntry(consoleEntryOrErrorBroadcastChannel, entry);
       }),
     );
 
@@ -310,7 +316,6 @@ export const startDbWorker =
       // waits on. The tab leader lock is unaffected.
       port.postMessage({
         type: "LeaderRefused",
-        name: initMessage.name,
         error: startup.error,
       });
       return ok();
@@ -322,7 +327,6 @@ export const startDbWorker =
 
     port.postMessage({
       type: "LeaderAcquired",
-      name: initMessage.name,
       clock: initialClock,
     });
 

package/src/local-first/Owner.test.ts

@@ -1,12 +1,21 @@
+import { bytesToHex } from "@noble/hashes/utils.js";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
 import { eqData } from "../Eq.ts";
 import { test } from "node:test";
-import { assertEqual, assertFalse, assertNotUndefined } from "../Assert.ts";
+import {
+  assertEqual,
+  assertFalse,
+  assertNotUndefined,
+  assertTrue,
+} from "../Assert.ts";
 
 import {
   createAppOwner,
   createOwnerSecret,
   deriveShardOwner,
   mnemonicToOwnerSecret,
+  OwnerSecret,
   ownerIdBytesToOwnerId,
   ownerIdToOwnerIdBytes,
   ownerSecretToMnemonic,
@@ -14,6 +23,7 @@ import {
   testOwnerSecret,
 } from "./Owner.ts";
 import { testCreateDeps } from "../Task.ts";
+import { Mnemonic } from "../Type.ts";
 
 const testOwnerSecret2 = createOwnerSecret(testCreateDeps({ seed: "owner-2" }));
 
@@ -31,6 +41,47 @@ test("ownerSecretToMnemonic and mnemonicToOwnerSecret are inverses", () => {
   assertEqual(backToSecret, secret);
 });
 
+test("mnemonicToOwnerSecret converts every BIP-39 mnemonic length", () => {
+  for (const [words, bytes] of [
+    [12, 16],
+    [15, 20],
+    [18, 24],
+    [21, 28],
+    [24, 32],
+  ] as const) {
+    const entropy = new Uint8Array(bytes).fill(words);
+    const mnemonic = Mnemonic.orThrow(
+      bip39.entropyToMnemonic(entropy, wordlist),
+    );
+    const secret = mnemonicToOwnerSecret(mnemonic);
+
+    assertEqual(mnemonic.split(" ").length, words);
+    assertTrue(OwnerSecret.is(secret));
+    assertEqual(secret, entropy);
+    assertEqual(ownerSecretToMnemonic(secret), mnemonic);
+  }
+});
+
+test("OwnerSecret rejects lengths that no mnemonic holds", () => {
+  assertFalse(OwnerSecret.is(new Uint8Array(17)));
+  assertFalse(OwnerSecret.is(new Uint8Array(64)));
+});
+
+test("createAppOwner derives fixed keys from a 12-word mnemonic", () => {
+  const owner = createAppOwner(
+    mnemonicToOwnerSecret(
+      Mnemonic.orThrow("all all all all all all all all all all all all"),
+    ),
+  );
+
+  assertEqual(owner.id, "njGMKFwCtldekpIYmB-VKA");
+  assertEqual(
+    bytesToHex(owner.encryptionKey),
+    "d9cae8d1e141e9f4824ba9b56b9b991d242c1a37f48a146053c3d69f432c5599",
+  );
+  assertEqual(bytesToHex(owner.writeKey), "8d77d62517c4d525223647a189261ab2");
+});
+
 test("createAppOwner is deterministic", () => {
   const owner1 = createAppOwner(testOwnerSecret);
   const owner2 = createAppOwner(testOwnerSecret);

package/src/local-first/Owner.ts

@@ -48,6 +48,9 @@ import {
   createSlip21,
   EncryptionKey,
   Entropy16,
+  Entropy20,
+  Entropy24,
+  Entropy28,
   Entropy32,
   testCreateRandomBytes,
 } from "../Crypto.ts";
@@ -62,6 +65,7 @@ import {
   Mnemonic,
   NonNegativeInt,
   type Typed,
+  union,
 } from "../Type.ts";
 import type { EncryptedDbChange, Storage } from "./Storage.ts";
 import { TimestampBytes } from "./Timestamp.ts";
@@ -172,18 +176,33 @@ export const createOwnerWriteKey = (deps: RandomBytesDep): OwnerWriteKey =>
   deps.randomBytes.create(16) as OwnerWriteKey;
 
 /**
- * 32 bytes of cryptographic entropy used to derive {@link Owner} keys.
+ * BIP-39 entropy used to derive {@link Owner} keys.
  *
- * Can be created using {@link createOwnerSecret} or converted from a
- * {@link Mnemonic} using {@link mnemonicToOwnerSecret}.
+ * A {@link Mnemonic} represents an OwnerSecret, so each valid mnemonic converts
+ * to exactly one secret with {@link mnemonicToOwnerSecret} and back with
+ * {@link ownerSecretToMnemonic}. A 24-word mnemonic holds 32 bytes, a 12-word
+ * mnemonic holds 16 bytes, and 15, 18, and 21 words hold 20, 24, and 28 bytes.
+ *
+ * {@link createOwnerSecret} generates 32 random bytes, which keep the owner
+ * post-quantum safe. The {@link OwnerId} is public and derived from the secret,
+ * so anyone who stores an owner's encrypted data can test guesses of the secret
+ * offline, and a quantum computer needs only about the square root of the
+ * guesses. 32 random bytes leave about 128 bits of security, while 16 bytes
+ * leave about 64. A secret derived from a smaller root, such as a 20-word
+ * SLIP-39 share, is no stronger than that root, whatever its length. Shorter
+ * secrets are accepted for owners created outside Evolu, typically from 12-word
+ * mnemonics.
  *
  * @group Core
  */
-export const OwnerSecret = /*#__PURE__*/ brand("OwnerSecret", Entropy32);
+export const OwnerSecret = /*#__PURE__*/ brand(
+  "OwnerSecret",
+  /*#__PURE__*/ union(Entropy16, Entropy20, Entropy24, Entropy28, Entropy32),
+);
 export type OwnerSecret = typeof OwnerSecret.Output;
 
 /**
- * Creates a cryptographically random {@link OwnerSecret}.
+ * Creates a cryptographically random 32-byte {@link OwnerSecret}.
  *
  * @group Core
  */
@@ -210,12 +229,12 @@ export const ownerSecretToMnemonic = (secret: OwnerSecret): Mnemonic =>
   bip39.entropyToMnemonic(secret, wordlist) as Mnemonic;
 
 /**
- * Converts a {@link Mnemonic} to an {@link OwnerSecret}.
+ * Converts a {@link Mnemonic} to the {@link OwnerSecret} it represents.
  *
  * @group Core
  */
 export const mnemonicToOwnerSecret = (mnemonic: Mnemonic): OwnerSecret =>
-  bip39.mnemonicToEntropy(mnemonic, wordlist) as OwnerSecret;
+  OwnerSecret.orThrow(bip39.mnemonicToEntropy(mnemonic, wordlist));
 
 /**
  * Creates an {@link Owner} from a {@link OwnerSecret} using SLIP-21 key