@evolu/common 8.0.0-next.4 → 8.0.0

package/dist/src/Sqlite.js

@@ -55,12 +55,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { assertNotDisposed } from "./Assert.js";
 import { bytesToHex, hexToBytes } from "./Buffer.js";
 import { createEqObject, eqArrayNumber, eqString } from "./Eq.js";
-import { createRecord, objectToEntries } from "./Object.js";
+import { disposable } from "./Function.js";
+import { createMutableRecord, objectToEntries } from "./Object.js";
 import { ok } from "./Result.js";
-import { testCreateRun } from "./Test.js";
+import { testCreateRun } from "./Task.js";
 import { array, Null, Number, object, record, set, String, testName, Uint8Array, union, } from "./Type.js";
 /**
  * A value that can be stored in {@link Sqlite}.
@@ -106,15 +106,10 @@ export const createSqlite = (name, options) => async (run) => {
         const { createSqliteDriver } = run.deps;
         const console = run.deps.console.child("sql");
         const disposer = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-        const driverResult = await run(createSqliteDriver(name, options));
-        if (!driverResult.ok)
-            return driverResult;
-        const driver = disposer.use(driverResult.value);
+        const driver = disposer.use(await run.ok(createSqliteDriver(name, options)));
         console.debug("SQLite driver created");
-        const disposables = disposer.move();
-        const sqlite = {
+        return ok(disposable({
             exec: (query) => {
-                assertNotDisposed(disposables);
                 console.debug({ query });
                 const label = query.options?.logQueryExecutionTime &&
                     `SqliteQueryExecutionTime ${query.sql}`;
@@ -137,7 +132,6 @@ export const createSqlite = (name, options) => async (run) => {
             transaction: ((callback) => {
                 const env_2 = { stack: [], error: void 0, hasError: false };
                 try {
-                    assertNotDisposed(disposables);
                     console.debug("begin");
                     driver.exec(sql `begin;`);
                     const rollback = __addDisposableResource(env_2, new DisposableStack(), false);
@@ -164,13 +158,8 @@ export const createSqlite = (name, options) => async (run) => {
                     __disposeResources(env_2);
                 }
             }),
-            export: () => {
-                assertNotDisposed(disposables);
-                return driver.export();
-            },
-            [Symbol.asyncDispose]: () => disposables.disposeAsync(),
-        };
-        return ok(sqlite);
+            export: () => driver.export(),
+        }, disposer));
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -188,10 +177,11 @@ export const testSetupSqlite = async (deps) => {
     try {
         const disposer = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
         const run = disposer.use(testCreateRun(deps));
-        const sqlite = disposer.use(await run.orThrow(createSqlite(testName, { mode: "memory" })));
+        const sqlite = disposer.use(await run.ok(createSqlite(testName, { mode: "memory" })));
+        const runWithSqlite = disposer.use(run.create({ ...run.deps, sqlite }));
         const disposables = disposer.move();
         return {
-            run: run.addDeps({ sqlite }),
+            run: runWithSqlite,
             sqlite,
             [Symbol.asyncDispose]: () => disposables.disposeAsync(),
         };
@@ -249,10 +239,8 @@ export const createPreparedStatementsCache = (factory, disposeFn) => {
                 __disposeResources(env_5);
             }
         });
-        const disposables = disposer.move();
-        return {
+        return disposable({
             get: (query, alwaysPrepare) => {
-                assertNotDisposed(disposables);
                 if (alwaysPrepare !== true && !query.options?.prepare)
                     return null;
                 let statement = statementsBySql.get(query.sql);
@@ -262,8 +250,7 @@ export const createPreparedStatementsCache = (factory, disposeFn) => {
                 }
                 return statement;
             },
-            [Symbol.dispose]: () => disposables.dispose(),
-        };
+        }, disposer);
     }
     catch (e_4) {
         env_4.error = e_4;
@@ -282,27 +269,32 @@ export const createPreparedStatementsCache = (factory, disposeFn) => {
  * ### Example
  *
  * ```ts
+ * import { sql } from "@evolu/common";
+ *
  * const id = 42;
  * const name = "Alice";
- *
- * const result = sqlite.exec(sql`
- *   select *
- *   from users
- *   where id = ${id} and name = ${name};
- * `);
- *
- * // For identifiers
+ * const select = sql`
+ *   select * from users where id = ${id} and name = ${name};
+ * `;
  * const tableName = "users";
- * sqlite.exec(sql`
+ * const createTable = sql`
  *   create table ${sql.identifier(tableName)} (
  *     "id" text primary key,
  *     "name" text not null
  *   );
- * `);
- *
- * // For raw SQL (use with caution)
+ * `;
+ * // Use sql.raw only with trusted SQL fragments.
  * const orderBy = "created_at desc";
- * sqlite.exec(sql`select * from users order by ${sql.raw(orderBy)};`);
+ * const ordered = sql`select * from users order by ${sql.raw(orderBy)};`;
+ *
+ * expect(select).toEqual({
+ *   sql: "select * from users where id = ? and name = ?;",
+ *   parameters: [42, "Alice"],
+ * });
+ * expect(createTable.sql).toContain('create table "users"');
+ * expect(ordered.sql).toBe(
+ *   "select * from users order by created_at desc;",
+ * );
  * ```
  *
  * ## TIP
@@ -364,7 +356,7 @@ export const SqliteSchema = /*#__PURE__*/ object({
 });
 /** Get the current SQLite schema by reading SQLite metadata. */
 export const getSqliteSchema = (deps) => ({ excludeIndexNamePrefix, } = {}) => {
-    const tables = createRecord();
+    const tables = createMutableRecord();
     const tableAndColumnInfoRows = deps.sqlite.exec(sql `
       select
         sqlite_master.name as tableName,
@@ -379,6 +371,7 @@ export const getSqliteSchema = (deps) => ({ excludeIndexNamePrefix, } = {}) => {
     const indexNamePrefixFilter = excludeIndexNamePrefix != null
         ? ` and name not like '${excludeIndexNamePrefix.replaceAll("'", "''")}%'`
         : "";
+    // prettier-ignore
     const indexesRows = deps.sqlite.exec(sql `
         select name, sql
         from sqlite_master
@@ -390,9 +383,9 @@ export const getSqliteSchema = (deps) => ({ excludeIndexNamePrefix, } = {}) => {
     const indexes = indexesRows.rows.map((row) => ({
         name: row.name,
         /**
-         * SQLite returns "CREATE INDEX" for "create index" for some reason.
-         * Other keywords remain unchanged. We have to normalize the casing for
-         * schema comparison manually.
+         * SQLite returns "CREATE INDEX" for "create index" for some reason. Other
+         * keywords remain unchanged. We have to normalize the casing for schema
+         * comparison manually.
          */
         sql: row.sql
             .replace("CREATE INDEX", "create index")
@@ -452,8 +445,9 @@ export const sqliteFalse = 0;
  * ### Example
  *
  * ```ts
- * const isActive = true;
- * const sqlValue = booleanToSqliteBoolean(isActive); // Returns 1
+ * import { booleanToSqliteBoolean } from "@evolu/common";
+ *
+ * expect(booleanToSqliteBoolean(true)).toBe(1);
  * ```
  */
 export const booleanToSqliteBoolean = (value) => value ? sqliteTrue : sqliteFalse;
@@ -463,8 +457,9 @@ export const booleanToSqliteBoolean = (value) => value ? sqliteTrue : sqliteFals
  * ### Example
  *
  * ```ts
- * const sqlValue: SqliteBoolean = 1;
- * const bool = sqliteBooleanToBoolean(sqlValue); // Returns true
+ * import { sqliteBooleanToBoolean } from "@evolu/common";
+ *
+ * expect(sqliteBooleanToBoolean(1)).toBe(true);
  * ```
  */
 export const sqliteBooleanToBoolean = (value) => value === sqliteTrue;

package/dist/src/StackTrace.d.ts

@@ -0,0 +1,40 @@
+/**
+ * JavaScript stack trace parsing utilities.
+ *
+ * @module
+ */
+export interface StackTraceFrame {
+    /** Function or frame label reported by the engine, if available. */
+    readonly name: string | undefined;
+    /** Basename of the source location without query or hash suffixes. */
+    readonly sourceName: string;
+    readonly location: string;
+    readonly lineNumber: number;
+    readonly columnNumber: number;
+}
+export interface StackTrace {
+    readonly frames: ReadonlyArray<StackTraceFrame>;
+    readonly names: ReadonlyArray<string>;
+    readonly files: ReadonlyArray<string>;
+    readonly sites: ReadonlyArray<string>;
+}
+export interface StackTraceOptions {
+    readonly maxSourceLabelLineOffset?: number;
+    readonly sourceLabel?: string;
+    readonly sourceLabelsByLine?: Map<number, string>;
+    readonly sourceNameAllowlist?: ReadonlySet<string>;
+    readonly sourceName?: string;
+}
+/**
+ * Parses V8, SpiderMonkey, and JavaScriptCore stack frames for tests.
+ *
+ * Warning: This is AI-slop containment code for tests, not production stack
+ * trace parsing infrastructure.
+ *
+ * This is intentionally not a complete stack trace parser. It extracts only
+ * frame names and source positions needed by async stack trace tests and
+ * similar assertions that need stable, cross-engine stack evidence.
+ */
+export declare function parseStackTrace(stack: string | undefined, options?: StackTraceOptions): StackTrace;
+export declare function parseStackTrace(run: () => Promise<never>, options?: StackTraceOptions): Promise<StackTrace>;
+//# sourceMappingURL=StackTrace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StackTrace.d.ts","sourceRoot":"","sources":["../../src/StackTrace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAChD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,UAAU,CAAC;AACd,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,EACzB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,UAAU,CAAC,CAAC"}

package/dist/src/StackTrace.js

@@ -0,0 +1,140 @@
+/**
+ * JavaScript stack trace parsing utilities.
+ *
+ * @module
+ */
+export function parseStackTrace(input, options = {}) {
+    if (typeof input === "function")
+        return (async () => {
+            try {
+                if (options.sourceLabel != null)
+                    parseStackTrace(new Error().stack, options);
+                await input();
+            }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+                const { sourceLabel: _sourceLabel, ...readOptions } = options;
+                return parseStackTrace(error.stack, readOptions);
+            }
+            throw new Error("Stack trace capture must throw.");
+        })();
+    const frames = parseStackTraceFrames(input).filter(({ sourceName }) => options.sourceNameAllowlist == null ||
+        options.sourceNameAllowlist.has(sourceName));
+    recordSourceLabel(frames, options);
+    return {
+        files: frames.map(({ sourceName }) => sourceName),
+        frames,
+        names: frames
+            .map(({ name }) => name)
+            .filter((name) => name !== undefined),
+        sites: sourceLabels(frames, options),
+    };
+}
+const parseStackTraceFrames = (stack) => (stack ?? "")
+    .split("\n")
+    .map(parseStackTraceLine)
+    .filter((frame) => frame !== undefined);
+const recordSourceLabel = (frames, { sourceLabel, sourceLabelsByLine, sourceName }) => {
+    if (sourceLabel == null || sourceLabelsByLine == null || sourceName == null)
+        return;
+    const frame = frames.find((frame) => frame.sourceName === sourceName);
+    if (frame == null)
+        return;
+    sourceLabelsByLine.set(frame.lineNumber, sourceLabel);
+};
+const sourceLabels = (frames, { maxSourceLabelLineOffset = 8, sourceLabelsByLine, sourceName, }) => {
+    if (sourceLabelsByLine == null || sourceName == null)
+        return [];
+    return frames.flatMap((frame) => {
+        if (frame.sourceName !== sourceName)
+            return [];
+        for (let offset = 0; offset <= maxSourceLabelLineOffset; offset += 1) {
+            const label = sourceLabelsByLine.get(frame.lineNumber - offset);
+            if (label != null)
+                return [label];
+        }
+        return [];
+    });
+};
+const parseStackTraceLine = (line) => {
+    const stackLine = parseStackLine(line);
+    if (stackLine == null)
+        return undefined;
+    const location = parseStackLocation(stackLine.location);
+    if (location == null)
+        return undefined;
+    return { ...location, name: stackLine.name };
+};
+const parseStackLine = (line) => {
+    let text = line.trim();
+    if (text === "")
+        return undefined;
+    if (text.startsWith("at ")) {
+        text = text.slice(3);
+        if (text.startsWith("async "))
+            text = text.slice(6);
+        const locationStart = text.lastIndexOf("(");
+        if (locationStart >= 0 && text.endsWith(")")) {
+            const name = stackFrameName(text.slice(0, locationStart).trim());
+            const location = text.slice(locationStart + 1, -1);
+            return { name, location };
+        }
+        return { location: text, name: undefined };
+    }
+    if (text.startsWith("async*"))
+        text = text.slice(6);
+    const locationStart = text.indexOf("@");
+    if (locationStart < 0)
+        return { location: text, name: undefined };
+    return {
+        location: text.slice(locationStart + 1),
+        name: stackFrameName(text.slice(0, locationStart)),
+    };
+};
+const parseStackLocation = (location) => {
+    const columnStart = location.lastIndexOf(":");
+    if (columnStart < 0)
+        return undefined;
+    const lineStart = location.lastIndexOf(":", columnStart - 1);
+    if (lineStart < 0)
+        return undefined;
+    const pathEnd = Math.max(location.lastIndexOf("/"), location.lastIndexOf("\\"));
+    if (lineStart <= pathEnd)
+        return undefined;
+    const lineNumber = parseLeadingInt(location.slice(lineStart + 1));
+    const columnNumber = parseLeadingInt(location.slice(columnStart + 1));
+    if (lineNumber == null || columnNumber == null)
+        return undefined;
+    return {
+        columnNumber,
+        lineNumber,
+        location,
+        sourceName: stackTraceSourceName(location.slice(0, lineStart)),
+    };
+};
+const stackTraceSourceName = (source) => {
+    const queryStart = source.indexOf("?");
+    const hashStart = source.indexOf("#");
+    const suffixStart = queryStart < 0
+        ? hashStart
+        : hashStart < 0
+            ? queryStart
+            : Math.min(queryStart, hashStart);
+    const path = suffixStart < 0 ? source : source.slice(0, suffixStart);
+    return path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")) + 1);
+};
+const parseLeadingInt = (value) => {
+    let end = 0;
+    while (end < value.length && isAsciiDigit(value.charCodeAt(end)))
+        end += 1;
+    if (end === 0)
+        return undefined;
+    return Number(value.slice(0, end));
+};
+const isAsciiDigit = (charCode) => charCode >= 48 && charCode <= 57;
+const stackFrameName = (value) => {
+    while (value.endsWith("/<"))
+        value = value.slice(0, -2);
+    return value === "" ? undefined : value;
+};

package/dist/src/Store.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import type { Eq } from "./Eq.js";
-import type { Ref } from "./Ref.js";
+import type { Eq } from "./Eq.ts";
+import type { Ref } from "./Ref.ts";
 /**
  * A store for managing state with change notifications. Like a {@link Ref} with
  * subscriptions.
@@ -43,8 +43,9 @@ export type Unsubscribe = () => void;
  * state, which can be read with `get` and updated with `set` or `update`. All
  * changes are broadcast to subscribers.
  *
- * By default, state changes are detected using strict equality (`===`). You can
- * provide a custom equality function as the second argument.
+ * By default, state changes are detected using {@link eqSameValueZero}, which
+ * considers `NaN` equal to itself and `0` equal to `-0`. You can provide a
+ * custom equality function as the second argument.
  */
 export declare const createStore: <T>(initialState: T, eq?: Eq<T>) => Store<T>;
 //# sourceMappingURL=Store.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/Store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC;;;;;;;GAOG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;CAAG;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,UAAU;IAClD,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAEtB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,WAAW,CAAC;CACzD;AAED,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,cAAc,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAqEnE,CAAC"}
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/Store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC;;;;;;;GAOG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;CAAG;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,UAAU;IAClD,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAEtB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,WAAW,CAAC;CACzD;AAED,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAqEnE,CAAC"}

package/dist/src/Store.js

@@ -3,18 +3,19 @@
  *
  * @module
  */
-import { eqStrict } from "./Eq.js";
+import { eqSameValueZero } from "./Eq.js";
 import { createRef } from "./Ref.js";
 /**
  * Creates a store with the given initial state. The store encapsulates its
  * state, which can be read with `get` and updated with `set` or `update`. All
  * changes are broadcast to subscribers.
  *
- * By default, state changes are detected using strict equality (`===`). You can
- * provide a custom equality function as the second argument.
+ * By default, state changes are detected using {@link eqSameValueZero}, which
+ * considers `NaN` equal to itself and `0` equal to `-0`. You can provide a
+ * custom equality function as the second argument.
  */
 export const createStore = (initialState, eq) => {
-    const equality = eq ?? eqStrict;
+    const equality = eq ?? eqSameValueZero;
     const ref = createRef(initialState);
     const listeners = new Set();
     const notifyIfChanged = (previousState) => {

package/dist/src/String.d.ts

@@ -1,7 +1,13 @@
 /**
- * String utilities for safe value conversion.
+ * String utilities.
  *
  * @module
  */
+/**
+ * Escapes regular-expression syntax so a string can be used as a literal
+ * pattern.
+ */
+export declare const escapeRegExp: (value: string) => string;
+/** Converts an unknown value to a compact, human-readable diagnostic string. */
 export declare const safelyStringifyUnknownValue: (value: unknown) => string;
 //# sourceMappingURL=String.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"String.d.ts","sourceRoot":"","sources":["../../src/String.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,2BAA2B,GAAI,OAAO,OAAO,KAAG,MAS5D,CAAC"}
+{"version":3,"file":"String.d.ts","sourceRoot":"","sources":["../../src/String.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MACC,CAAC;AAE/C,gFAAgF;AAChF,eAAO,MAAM,2BAA2B,UAAW,OAAO,KAAG,MAkB5D,CAAC"}

package/dist/src/String.js

@@ -1,19 +1,32 @@
 /**
- * String utilities for safe value conversion.
+ * String utilities.
  *
  * @module
  */
+/**
+ * Escapes regular-expression syntax so a string can be used as a literal
+ * pattern.
+ */
+export const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Converts an unknown value to a compact, human-readable diagnostic string. */
 export const safelyStringifyUnknownValue = (value) => {
-    if (value === null)
-        return "null";
-    if (value === undefined)
-        return "undefined";
     if (typeof value === "string")
-        return `"${value}"`;
-    try {
         return JSON.stringify(value);
+    if (value === null || typeof value !== "object")
+        return globalThis.String(value);
+    try {
+        // `JSON.stringify` can return `undefined` when `toJSON` does.
+        const stringifiedValue = JSON.stringify(value);
+        if (typeof stringifiedValue === "string")
+            return stringifiedValue;
     }
     catch {
+        // Fall through to a simpler representation.
+    }
+    try {
         return globalThis.String(value);
     }
+    catch {
+        return "[Unserializable value]";
+    }
 };