@marimo-team/islands 0.24.3-dev9 → 0.25.1-dev1

package/src/components/editor/output/__tests__/{json-output.test.ts → json-output-formatting.test.ts}

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { describe, expect, it } from "vitest";
-import { determineMaxDisplayLength, getCopyValue } from "../JsonOutput";
+import { getCopyValue } from "../json-output/formatting";
 
 describe("getCopyValue", () => {
   it("should handle strings without MIME prefixes", () => {
@@ -178,7 +178,6 @@ describe("getCopyValue", () => {
   });
 
   it("should handle empty set", () => {
-    // Empty set literal in Python is `set()`, not `{}` (which is a dict).
     expect(getCopyValue("text/plain+set:[]")).toMatchInlineSnapshot(`"set()"`);
   });
 
@@ -212,7 +211,7 @@ describe("getCopyValue", () => {
   it("should handle tuples", () => {
     const value = "text/plain+tuple:[1,2,3]";
     const result = getCopyValue(value);
-    expect(result).toMatchInlineSnapshot(`"(1,2,3)"`);
+    expect(result).toMatchInlineSnapshot(`"(1, 2, 3)"`);
   });
 
   it("should handle tuples in mixed types", () => {
@@ -226,7 +225,7 @@ describe("getCopyValue", () => {
       `
       "{
         "key1": 42,
-        "key2": (1,2,3),
+        "key2": (1, 2, 3),
         "key3": True
       }"
     `,
@@ -240,8 +239,8 @@ describe("getCopyValue", () => {
     expect(result).toMatchInlineSnapshot(`"18446744073709551616"`);
 
     const nestedBigInt = {
-      key1: bigint, // this will be just a string
-      key2: `text/plain+bigint:${bigint}`, // this will convert to number
+      key1: bigint,
+      key2: `text/plain+bigint:${bigint}`,
       key3: true,
     };
     const nestedResult = getCopyValue(nestedBigInt);
@@ -260,7 +259,7 @@ describe("getCopyValue", () => {
     expect(bigintRawResult).toMatchInlineSnapshot(`"18446744073709551616"`);
 
     const nestedBigIntRaw = {
-      key1: bigintRaw, // raw number
+      key1: bigintRaw,
       key2: `text/plain+bigint:${bigintRaw}`,
       key3: true,
     };
@@ -277,64 +276,8 @@ describe("getCopyValue", () => {
   });
 });
 
-describe("determineMaxDisplayLength", () => {
-  const sample2DArray = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9],
-    [10, 11, 12],
-    [13, 14, 15],
-    [16, 17, 18],
-    [19, 20, 21],
-    [22, 23, 24],
-    [25, 26, 27],
-    [28, 29, 30],
-  ];
-
-  it("should return undefined for 1 level arrays", () => {
-    const value = [1, 2, 3];
-    const result = determineMaxDisplayLength(value);
-    expect(result).toBeUndefined();
-  });
-
-  it("should return undefined for 2 level arrays with less than 20 items", () => {
-    const value = sample2DArray;
-    const result = determineMaxDisplayLength(value);
-    expect(result).toBeUndefined();
-  });
-
-  it("should return 10 for 2 level arrays with more than 20 items", () => {
-    const longArray = Array.from({ length: 21 }, (_, i) => i);
-    const value = [...sample2DArray, longArray];
-    const result = determineMaxDisplayLength(value);
-    expect(result).toBe(10);
-  });
-
-  it("should return 5 for 2 level arrays with more than 50 items", () => {
-    const longArray = Array.from({ length: 51 }, (_, i) => i);
-    const value = [...sample2DArray, longArray];
-    const result = determineMaxDisplayLength(value);
-    expect(result).toBe(5);
-  });
-
-  it("should return 5 for 3 level arrays with more than 20 items", () => {
-    const longArray = Array.from({ length: 21 }, (_, i) => i);
-    const value = [[...sample2DArray], [...sample2DArray, longArray]];
-    const result = determineMaxDisplayLength(value);
-    expect(result).toBe(5);
-  });
-});
-
 describe("getCopyValue with encoded non-string keys", () => {
-  // Keys are encoded by _key_formatter in
-  // marimo/_output/formatters/structures.py. Frontend must round-trip them
-  // to Python literals in the copy output.
-
   it("decodes int keys unquoted", () => {
-    // JS reorders integer-like string keys to the front of object iteration
-    // (spec-mandated), so `"2"` appears before `"text/plain+int:2"` here.
-    // This is pre-existing and unrelated to the encoding — both entries
-    // survive, which is the regression this guards.
     const value = { "text/plain+int:2": "no", "2": "oh" };
     expect(getCopyValue(value)).toMatchInlineSnapshot(`
       "{
@@ -375,7 +318,6 @@ describe("getCopyValue with encoded non-string keys", () => {
   });
 
   it("emits 1-element tuple keys with a trailing comma (Python syntax)", () => {
-    // `(1)` is just `1` in Python — a 1-tuple needs `(1,)`.
     const value = {
       "text/plain+tuple:[1]": "one",
       "text/plain+tuple:[]": "empty",
@@ -389,7 +331,6 @@ describe("getCopyValue with encoded non-string keys", () => {
   });
 
   it("emits empty frozenset keys as `frozenset()` not `frozenset({})`", () => {
-    // `frozenset({})` reads like it's constructing from an empty dict.
     const value = {
       "text/plain+frozenset:[]": "empty",
       "text/plain+frozenset:[1]": "single",
@@ -418,12 +359,6 @@ describe("getCopyValue with encoded non-string keys", () => {
   });
 
   it("parses tuple/frozenset payloads containing bare NaN/Infinity", () => {
-    // Python's json.dumps emits bare `NaN`/`Infinity` inside the embedded
-    // tuple/frozenset payload strings (JSON spec violation, but ECMA-262-
-    // friendly via the fallback in jsonParseWithSpecialChar). The outer
-    // JSON stays strict because those tokens live inside a JSON string
-    // key/value. Regression for tuple-key payloads that previously broke
-    // the frontend's `JSON.parse` and threw.
     const value = {
       "text/plain+tuple:[NaN]": "tn",
       "text/plain+tuple:[Infinity, -Infinity]": "ti",
@@ -439,10 +374,6 @@ describe("getCopyValue with encoded non-string keys", () => {
   });
 
   it("falls back to the raw payload for malformed tuple/frozenset", () => {
-    // `jsonParseWithSpecialChar` returns `{}` on parse failure rather
-    // than throwing; without an `Array.isArray` guard, the formatters
-    // would crash on `.length`/`.map`. Pass the raw payload through so
-    // a malformed wire form doesn't break the whole render.
     const value = {
       "text/plain+tuple:not a json list": "t",
       k: "text/plain+frozenset:also broken",
@@ -513,3 +444,110 @@ describe("getCopyValue with application/ mimetypes", () => {
     expect(result).toContain('"number": 42');
   });
 });
+
+describe("Python copy fidelity", () => {
+  it.each([
+    "<marimo-replace>True</marimo-replace>",
+    "\u0000show_more\u000042|$",
+    'quotes " backslash \\ newline\n',
+  ])("preserves literal text %j", (value) => {
+    expect(getCopyValue(value)).toBe(JSON.stringify(value));
+  });
+
+  it("preserves keys which used to collide after decoding", () => {
+    const data = JSON.parse(
+      '{"__proto__":1,"<marimo-replace>2</marimo-replace>":2,"text/plain+int:2":3}',
+    );
+    expect(getCopyValue(data)).toBe(
+      '{\n  "__proto__": 1,\n  "<marimo-replace>2</marimo-replace>": 2,\n  2: 3\n}',
+    );
+  });
+
+  it.each([
+    ["text/plain+tuple:[42]", "(42,)"],
+    ["text/plain+tuple:[]", "()"],
+    [
+      'text/plain+tuple:["quote\\\"","back\\\\slash",true,null]',
+      '("quote\\\"", "back\\\\slash", True, None)',
+    ],
+    [
+      'text/plain+set:[true,null,"text/plain:literal"]',
+      '{True, None, "text/plain:literal"}',
+    ],
+    ['text/plain+tuple:["text/plain+int:2"]', '("text/plain+int:2",)'],
+    ["text/plain+float:nan", "float('nan')"],
+    ["text/plain+float:inf", "float('inf')"],
+    ["text/plain+float:-inf", "-float('inf')"],
+    ["text/plain+float:1.0", "1.0"],
+  ])("copies %s as valid Python", (data, expected) => {
+    expect(getCopyValue(data)).toBe(expected);
+  });
+
+  it("distinguishes shared references from cycles", () => {
+    const shared = { x: true };
+    expect(getCopyValue([shared, shared])).toBe(
+      '[\n  {\n    "x": True\n  },\n  {\n    "x": True\n  }\n]',
+    );
+    const cyclic: unknown[] = [];
+    cyclic.push(cyclic);
+    expect(() => getCopyValue(cyclic)).toThrow("Cannot copy circular data");
+  });
+
+  it("copies sparse arrays and non-finite numbers as Python literals", () => {
+    const values = [0, Number.NaN, Infinity, -Infinity];
+    Reflect.deleteProperty(values, "0");
+    expect(getCopyValue(values)).toBe(
+      "[\n  None,\n  float('nan'),\n  float('inf'),\n  -float('inf')\n]",
+    );
+  });
+});
+
+describe("Python copy negative cases", () => {
+  it.each([
+    "text/plain+unknown:payload",
+    "text/plain+tuple",
+    "not-text/plain:payload",
+    "https://example.com:a:b",
+  ])("does not decode unrecognized leaf %j", (value) => {
+    expect(getCopyValue(value)).toBe(JSON.stringify(value));
+    expect(getCopyValue({ [value]: "literal" })).toBe(
+      `{\n  ${JSON.stringify(value)}: "literal"\n}`,
+    );
+  });
+
+  it.each(["tuple", "set", "frozenset"])(
+    "does not invent a %s from malformed or non-array JSON",
+    (kind) => {
+      for (const payload of ["[broken", "null", "42", '{"x":1}']) {
+        expect(getCopyValue(`text/plain+${kind}:${payload}`)).toBe(payload);
+      }
+    },
+  );
+
+  it("decodes escaped keys and text exactly once", () => {
+    const data = {
+      "text/plain+str:text/plain+str:text/plain+int:2":
+        "text/plain:text/plain+tuple:[42]",
+    };
+    expect(getCopyValue(data)).toBe(
+      '{\n  "text/plain+str:text/plain+int:2": "text/plain+tuple:[42]"\n}',
+    );
+  });
+
+  it("does not decode dictionary keys inside raw tuple payloads", () => {
+    expect(
+      getCopyValue(
+        'text/plain+tuple:[{"text/plain+int:2":"text/plain:literal"}]',
+      ),
+    ).toBe('({"text/plain+int:2": "text/plain:literal"},)');
+  });
+
+  it("rejects indirect cycles without poisoning later copies", () => {
+    const data: Record<string, unknown> = { child: [] };
+    data.child = [data];
+    expect(() => getCopyValue(data)).toThrow("Cannot copy circular data");
+    expect(getCopyValue({ child: [true] })).toBe(
+      '{\n  "child": [\n    True\n  ]\n}',
+    );
+  });
+});

package/src/components/editor/output/__tests__/json-output-pagination.test.ts

@@ -0,0 +1,252 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it, vi } from "vitest";
+import {
+  determineMaxDisplayLength,
+  estimateExpandedLines,
+  paginateJson,
+} from "../json-output/pagination";
+
+describe("determineMaxDisplayLength", () => {
+  const sample2DArray = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+    [10, 11, 12],
+    [13, 14, 15],
+    [16, 17, 18],
+    [19, 20, 21],
+    [22, 23, 24],
+    [25, 26, 27],
+    [28, 29, 30],
+  ];
+
+  it("should return undefined for 1 level arrays", () => {
+    const value = [1, 2, 3];
+    const result = determineMaxDisplayLength(value);
+    expect(result).toBeUndefined();
+  });
+
+  it("should return undefined for 2 level arrays with less than 20 items", () => {
+    const value = sample2DArray;
+    const result = determineMaxDisplayLength(value);
+    expect(result).toBeUndefined();
+  });
+
+  it("should return 10 for 2 level arrays with more than 20 items", () => {
+    const longArray = Array.from({ length: 21 }, (_, i) => i);
+    const value = [...sample2DArray, longArray];
+    const result = determineMaxDisplayLength(value);
+    expect(result).toBe(10);
+  });
+
+  it("should return 5 for 2 level arrays with more than 50 items", () => {
+    const longArray = Array.from({ length: 51 }, (_, i) => i);
+    const value = [...sample2DArray, longArray];
+    const result = determineMaxDisplayLength(value);
+    expect(result).toBe(5);
+  });
+
+  it("should return 5 for 3 level arrays with more than 20 items", () => {
+    const longArray = Array.from({ length: 21 }, (_, i) => i);
+    const value = [[...sample2DArray], [...sample2DArray, longArray]];
+    const result = determineMaxDisplayLength(value);
+    expect(result).toBe(5);
+  });
+});
+
+describe("estimateExpandedLines", () => {
+  it("scalars count as 1", () => {
+    expect(estimateExpandedLines(42, 100)).toBe(1);
+    expect(estimateExpandedLines(null, 100)).toBe(1);
+  });
+
+  it("flat containers = child count", () => {
+    expect(estimateExpandedLines({ a: 1, b: 2, c: 3 }, 100)).toBe(3);
+    expect(estimateExpandedLines([1, 2, 3, 4], 100)).toBe(4);
+  });
+
+  it("small nested children expand recursively", () => {
+    expect(estimateExpandedLines({ a: { x: 1, y: 2 }, b: 3 }, 100)).toBe(3);
+  });
+
+  it("large children count as 1 collapsed line", () => {
+    const big = Array.from({ length: 20 }, (_, i) => i);
+    expect(estimateExpandedLines({ a: big, b: 1 }, 100)).toBe(2);
+  });
+
+  it("bails at cap", () => {
+    const big = Array.from({ length: 500 }, (_, i) => i);
+    expect(estimateExpandedLines(big, 50)).toBe(50);
+  });
+
+  it("bails at max depth", () => {
+    const data = { a: { b: { c: { d: { e: { f: 1 } } } } } };
+    expect(estimateExpandedLines(data, 100)).toBe(1);
+  });
+});
+
+describe("paginateJson", () => {
+  const options = { limits: {}, pageSize: 30 };
+
+  it("preserves full originals and reports the remaining count", () => {
+    const rows = Array.from({ length: 100 }, (_, i) => i);
+    const data = { rows };
+    const tree = paginateJson(data, options);
+    const displayRows: unknown[] = Reflect.get(tree.data, "rows");
+    expect(displayRows.slice(0, 30)).toEqual(rows.slice(0, 30));
+    expect(tree.getPage(displayRows[30])).toEqual({
+      path: '["rows"]',
+      remaining: 70,
+    });
+    expect(tree.getOriginal(tree.data)).toBe(data);
+    expect(tree.getOriginal(displayRows)).toBe(rows);
+    expect(tree.getOriginal("value")).toBe("value");
+  });
+
+  it("paginates arrays and objects at the boundary", () => {
+    for (const count of [0, 1, 29, 30, 31, 60]) {
+      const values = Array.from({ length: count }, (_, i) => i);
+      for (const data of [
+        values,
+        Object.fromEntries(values.map((i) => [`k${i}`, i])),
+      ]) {
+        const tree = paginateJson(data, options);
+        const displayed = Object.values(tree.data);
+        expect(displayed.slice(0, 30)).toEqual(values.slice(0, 30));
+        expect(displayed).toHaveLength(
+          Math.min(count, 30) + Number(count > 30),
+        );
+        expect(tree.getPage(displayed.at(-1))).toEqual(
+          count > 30 ? { path: "[]", remaining: count - 30 } : undefined,
+        );
+      }
+    }
+  });
+
+  it("keeps dotted, quoted, and empty keys distinct without reserving user strings", () => {
+    const values = Array.from({ length: 40 }, (_, i) => i);
+    const data = { "a.b": values, a: { b: values }, '"': values, "": values };
+    const tree = paginateJson(data, { ...options, limits: { '["a.b"]': 60 } });
+    expect(Reflect.get(tree.data, "a.b")).toEqual(values);
+    for (const path of [["a", "b"], ['"'], [""]]) {
+      const node = path.reduce(
+        (node: object, key) => Reflect.get(node, key),
+        tree.data,
+      );
+      expect(tree.getPage(Object.values(node).at(-1))).toEqual({
+        path: JSON.stringify(path),
+        remaining: 10,
+      });
+    }
+    expect(tree.getPage("\u0000show_more\u000040|$")).toBeUndefined();
+    expect(tree.getPage(Symbol("show more"))).toBeUndefined();
+  });
+
+  it("preserves __proto__ and empty keys when adding an object page", () => {
+    const data = { "": 1, ["__proto__"]: 2, other: 3 };
+    const tree = paginateJson(data, { limits: {}, pageSize: 2 });
+    expect(Object.values(tree.data).slice(0, 2)).toEqual([1, 2]);
+    expect(tree.getOriginal(tree.data)).toBe(data);
+    expect(tree.getPage(Object.values(tree.data).at(-1))).toEqual({
+      path: "[]",
+      remaining: 1,
+    });
+  });
+
+  it("does not traverse hidden branches, and caches visible children", () => {
+    const read = vi.fn(() => [1, 2]);
+    const hidden = vi.fn(() => [3, 4]);
+    const data = {
+      get visible() {
+        return read();
+      },
+      get hidden() {
+        return hidden();
+      },
+    };
+    const tree = paginateJson(data, { limits: {}, pageSize: 1 });
+    expect(read).not.toHaveBeenCalled();
+    const first = Reflect.get(tree.data, "visible");
+    expect(Reflect.get(tree.data, "visible")).toBe(first);
+    expect(read).toHaveBeenCalledOnce();
+    expect(hidden).not.toHaveBeenCalled();
+  });
+
+  it("paginates deep branches without a depth cutoff", () => {
+    const data = {
+      deep: {
+        more: {
+          levels: {
+            still: {
+              going: {
+                deeper: { rows: Array.from({ length: 100 }, (_, i) => i) },
+              },
+            },
+          },
+        },
+      },
+    };
+    const tree = paginateJson(data, options);
+    const keys = ["deep", "more", "levels", "still", "going", "deeper", "rows"];
+    const rows = keys.reduce(
+      (node: object, key) => Reflect.get(node, key),
+      tree.data,
+    );
+    expect(Object.values(rows)).toHaveLength(31);
+    expect(tree.getPage(Object.values(rows).at(-1))).toEqual({
+      path: JSON.stringify(keys),
+      remaining: 70,
+    });
+  });
+
+  it("preserves non-JSON objects and does not mutate input", () => {
+    const date = new Date("2026-01-01");
+    const data = Object.freeze({ date, values: Object.freeze([1, 2, 3]) });
+    const tree = paginateJson(data, { limits: {}, pageSize: 2 });
+    expect(Reflect.get(tree.data, "date")).toBe(date);
+    expect(Object.values(Reflect.get(tree.data, "values"))).toHaveLength(3);
+    expect(data.values).toEqual([1, 2, 3]);
+  });
+});
+
+describe("pagination negative cases", () => {
+  it("does not overwrite empty or NUL keys with pagination controls", () => {
+    const data = { "": "empty", "\0": "nul", "\0\0": "two", last: "last" };
+    const tree = paginateJson(data, { limits: {}, pageSize: 3 });
+    expect(Object.values(tree.data).slice(0, 3)).toEqual([
+      "empty",
+      "nul",
+      "two",
+    ]);
+    expect(tree.getPage(Object.values(tree.data).at(-1))).toEqual({
+      path: "[]",
+      remaining: 1,
+    });
+    expect(Object.keys(data)).toEqual(["", "\0", "\0\0", "last"]);
+  });
+
+  it("does not accept page markers from another tree", () => {
+    const first = paginateJson([1, 2], { limits: {}, pageSize: 1 });
+    const second = paginateJson([3, 4], { limits: {}, pageSize: 1 });
+    expect(second.getPage(Object.values(first.data).at(-1))).toBeUndefined();
+  });
+
+  it("does not read values beyond the visible page", () => {
+    const data = {
+      visible: 1,
+      get hidden() {
+        throw new Error("hidden value read");
+      },
+    };
+    const tree = paginateJson(data, { limits: {}, pageSize: 1 });
+    expect(Object.values(tree.data)[0]).toBe(1);
+    expect(tree.getOriginal(tree.data)).toBe(data);
+  });
+
+  it("does not expose inherited or non-enumerable fields", () => {
+    const data = Object.defineProperty({ visible: 1 }, "hidden", { value: 2 });
+    const tree = paginateJson(data, { limits: {}, pageSize: 30 });
+    expect(Object.entries(tree.data)).toEqual([["visible", 1]]);
+    expect(Reflect.get(tree.data, "toString")).toBeUndefined();
+  });
+});

package/src/components/editor/output/json-output/formatting.ts

@@ -0,0 +1,167 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { jsonParseWithSpecialChar } from "@/utils/json/json-parser";
+
+export function splitLeaf(leaf: string): [string, string | undefined] {
+  const index = leaf.indexOf(":");
+  return index < 0
+    ? [leaf, undefined]
+    : [leaf.slice(index + 1), leaf.slice(0, index)];
+}
+
+function formatFloat(value: string): string {
+  switch (value.toLowerCase()) {
+    case "nan":
+      return "float('nan')";
+    case "inf":
+    case "infinity":
+      return "float('inf')";
+    case "-inf":
+    case "-infinity":
+      return "-float('inf')";
+    default:
+      return value;
+  }
+}
+
+function formatCollection(
+  payload: string,
+  kind: "tuple" | "set" | "frozenset",
+): string {
+  const items = jsonParseWithSpecialChar<unknown>(payload);
+  // Older servers sent Python literals instead of JSON lists.
+  if (!Array.isArray(items)) {
+    return payload;
+  }
+  const inner = items.map((item) => formatPython(item, true)).join(", ");
+  switch (kind) {
+    case "tuple":
+      return `(${inner}${items.length === 1 ? "," : ""})`;
+    case "set":
+      return items.length ? `{${inner}}` : "set()";
+    case "frozenset":
+      return items.length ? `frozenset({${inner}})` : "frozenset()";
+  }
+}
+
+export const formatTuplePayload = (payload: string) =>
+  formatCollection(payload, "tuple");
+export const formatSetPayload = (payload: string) =>
+  formatCollection(payload, "set");
+export const formatFrozensetPayload = (payload: string) =>
+  formatCollection(payload, "frozenset");
+
+// Matches the key encoding in marimo/_output/formatters/structures.py.
+export function decodePythonKey(
+  key: unknown,
+): { text: string; quoted: boolean } | undefined {
+  if (typeof key !== "string") {
+    return undefined;
+  }
+  const [payload, mime] = splitLeaf(key);
+  switch (mime) {
+    case "text/plain+str":
+      return { text: payload, quoted: true };
+    case "text/plain+int":
+    case "text/plain+float":
+      return { text: payload, quoted: false };
+    case "text/plain+bool":
+      return { text: payload === "True" ? "True" : "False", quoted: false };
+    case "text/plain+none":
+      return { text: "None", quoted: false };
+    case "text/plain+tuple":
+      return { text: formatTuplePayload(payload), quoted: false };
+    case "text/plain+frozenset":
+      return { text: formatFrozensetPayload(payload), quoted: false };
+    default:
+      return undefined;
+  }
+}
+
+function formatKey(key: string): string {
+  const decoded = decodePythonKey(key);
+  if (!decoded) {
+    return JSON.stringify(key);
+  }
+  if (decoded.quoted) {
+    return JSON.stringify(decoded.text);
+  }
+  return key.startsWith("text/plain+float:")
+    ? formatFloat(decoded.text)
+    : decoded.text;
+}
+
+function formatString(value: string): string {
+  const [payload, mime] = splitLeaf(value);
+  switch (mime) {
+    case "text/plain+float":
+      return formatFloat(payload);
+    case "text/plain+bigint":
+      return BigInt(payload).toString();
+    case "text/plain+tuple":
+      return formatTuplePayload(payload);
+    case "text/plain+set":
+      return formatSetPayload(payload);
+    case "text/plain+frozenset":
+      return formatFrozensetPayload(payload);
+    case "text/plain":
+    case "text/html":
+    case "text/markdown":
+      return JSON.stringify(payload);
+    default:
+      return JSON.stringify(
+        mime && /^(image|video|application)\//.test(mime) ? payload : value,
+      );
+  }
+}
+
+function formatPython(value: unknown, compact = false): string {
+  const ancestors = new WeakSet<object>();
+  function format(node: unknown, depth: number): string {
+    if (node == null) {
+      return "None";
+    }
+    switch (typeof node) {
+      case "string":
+        return compact ? JSON.stringify(node) : formatString(node);
+      case "boolean":
+        return node ? "True" : "False";
+      case "number":
+        return formatFloat(String(node));
+      case "bigint":
+        return node.toString();
+      case "object":
+        if (ancestors.has(node)) {
+          throw new TypeError("Cannot copy circular data");
+        }
+        ancestors.add(node);
+        try {
+          const array = Array.isArray(node);
+          const entries = array
+            ? Array.from(node, (item) => format(item, depth + 1))
+            : Object.entries(node).map(
+                ([key, item]) =>
+                  `${compact ? JSON.stringify(key) : formatKey(key)}: ${format(item, depth + 1)}`,
+              );
+          const [open, close] = array ? ["[", "]"] : ["{", "}"];
+          if (entries.length === 0) {
+            return open + close;
+          }
+          if (compact) {
+            return `${open}${entries.join(", ")}${close}`;
+          }
+          const indent = "  ".repeat(depth);
+          return `${open}\n${indent}  ${entries.join(`,\n${indent}  `)}\n${indent}${close}`;
+        } finally {
+          ancestors.delete(node);
+        }
+
+      default:
+        return "None";
+    }
+  }
+  return format(value, 0);
+}
+
+export function getCopyValue(value: unknown): string {
+  return formatPython(value);
+}