@sundaeswap/sprinkles 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sundaeswap/sprinkles",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A TypeScript library for building interactive CLI menus and TUI applications with TypeBox schema validation",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/Sprinkle/__tests__/encryption.test.ts

@@ -8,6 +8,9 @@ import { withProfile } from "./test-helpers.js";
 const mockSelect = mock();
 const mockInput = mock();
 const mockPassword = mock();
+const mockSelectCancellable = mock();
+const mockInputCancellable = mock();
+const mockPasswordCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
   select: mockSelect,
@@ -15,6 +18,13 @@ mock.module("@inquirer/prompts", () => ({
   password: mockPassword,
 }));
 
+mock.module("../prompts.js", () => ({
+  selectCancellable: mockSelectCancellable,
+  inputCancellable: mockInputCancellable,
+  passwordCancellable: mockPasswordCancellable,
+  confirmCancellable: mock(),
+}));
+
 describe("Encryption & Sensitive Fields", () => {
   let tmpDir: string;
 
@@ -23,6 +33,9 @@ describe("Encryption & Sensitive Fields", () => {
     mockSelect.mockClear();
     mockInput.mockClear();
     mockPassword.mockClear();
+    mockSelectCancellable.mockClear();
+    mockInputCancellable.mockClear();
+    mockPasswordCancellable.mockClear();
   });
 
   afterEach(() => {
@@ -36,13 +49,13 @@ describe("Encryption & Sensitive Fields", () => {
       });
       const sprinkle = new Sprinkle(schema, tmpDir);
 
-      mockPassword.mockResolvedValueOnce("my-secret");
+      mockPasswordCancellable.mockResolvedValueOnce("my-secret");
 
       const result = await sprinkle.FillInStruct(schema);
       expect(result).toEqual({ secret: "my-secret" });
-      expect(mockPassword).toHaveBeenCalledTimes(1);
-      expect(mockPassword.mock.calls[0][0].message).toBe("Enter secret");
-      expect(mockInput).not.toHaveBeenCalled();
+      expect(mockPasswordCancellable).toHaveBeenCalledTimes(1);
+      expect(mockPasswordCancellable.mock.calls[0][0].message).toBe("Enter secret");
+      expect(mockInputCancellable).not.toHaveBeenCalled();
     });
 
     test("uses input() for non-sensitive string fields", async () => {
@@ -51,19 +64,19 @@ describe("Encryption & Sensitive Fields", () => {
       });
       const sprinkle = new Sprinkle(schema, tmpDir);
 
-      mockInput.mockResolvedValueOnce("visible");
+      mockInputCancellable.mockResolvedValueOnce("visible");
 
       const result = await sprinkle.FillInStruct(schema);
       expect(result).toEqual({ name: "visible" });
-      expect(mockInput).toHaveBeenCalledTimes(1);
-      expect(mockPassword).not.toHaveBeenCalled();
+      expect(mockInputCancellable).toHaveBeenCalledTimes(1);
+      expect(mockPasswordCancellable).not.toHaveBeenCalled();
     });
 
     test("does not remember sensitive field as default", async () => {
       const schema = Type.String({ sensitive: true });
       const sprinkle = new Sprinkle(Type.Object({ p: Type.String() }), tmpDir);
 
-      mockPassword.mockResolvedValueOnce("secret-val");
+      mockPasswordCancellable.mockResolvedValueOnce("secret-val");
 
       await sprinkle.FillInStruct(schema);
       expect(sprinkle.defaults["string"]).toBeUndefined();

package/src/Sprinkle/__tests__/enhancements.test.ts

@@ -4,13 +4,25 @@ import { Sprinkle, Type, type IMenu } from "../index.js";
 const mockSelect = mock();
 const mockInput = mock();
 const mockPassword = mock();
-const mockSearch = mock();
+const mockSelectCancellable = mock();
+const mockInputCancellable = mock();
+const mockPasswordCancellable = mock();
+const mockConfirmCancellable = mock();
+const mockSearchCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
   select: mockSelect,
   input: mockInput,
   password: mockPassword,
-  search: mockSearch,
+}));
+
+mock.module("../prompts.js", () => ({
+  selectCancellable: mockSelectCancellable,
+  inputCancellable: mockInputCancellable,
+  passwordCancellable: mockPasswordCancellable,
+  confirmCancellable: mockConfirmCancellable,
+  searchCancellable: mockSearchCancellable,
+  select: mockSelectCancellable,
 }));
 
 describe("beforeShow hook (2.2)", () => {
@@ -21,6 +33,7 @@ describe("beforeShow hook (2.2)", () => {
     sprinkle = new Sprinkle(schema, "/tmp/test");
     sprinkle.settings = { name: "test" } as any;
     mockSelect.mockClear();
+    mockSelectCancellable.mockClear();
   });
 
   test("calls beforeShow before rendering menu", async () => {
@@ -30,7 +43,7 @@ describe("beforeShow hook (2.2)", () => {
       callOrder.push("beforeShow");
     });
 
-    mockSelect.mockImplementation(async () => {
+    mockSelectCancellable.mockImplementation(async () => {
       callOrder.push("select");
       return -1; // exit
     });
@@ -51,7 +64,7 @@ describe("beforeShow hook (2.2)", () => {
   test("passes sprinkle instance to beforeShow", async () => {
     let receivedSprinkle: any;
 
-    mockSelect.mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -66,7 +79,7 @@ describe("beforeShow hook (2.2)", () => {
   });
 
   test("menu works without beforeShow", async () => {
-    mockSelect.mockResolvedValueOnce(-1);
+    mockSelectCancellable.mockResolvedValueOnce(-1);
 
     const menu: IMenu<any> = {
       title: "Test",
@@ -80,11 +93,11 @@ describe("beforeShow hook (2.2)", () => {
 
 describe("SearchSelect (2.3)", () => {
   beforeEach(() => {
-    mockSearch.mockClear();
+    mockSearchCancellable.mockClear();
   });
 
   test("delegates to search prompt", async () => {
-    mockSearch.mockResolvedValueOnce("selected-value");
+    mockSearchCancellable.mockResolvedValueOnce("selected-value");
 
     const result = await Sprinkle.SearchSelect({
       message: "Pick one",
@@ -95,20 +108,31 @@ describe("SearchSelect (2.3)", () => {
     });
 
     expect(result).toBe("selected-value");
-    expect(mockSearch).toHaveBeenCalledTimes(1);
-    expect(mockSearch.mock.calls[0][0].message).toBe("Pick one");
+    expect(mockSearchCancellable).toHaveBeenCalledTimes(1);
+    expect(mockSearchCancellable.mock.calls[0][0].message).toBe("Pick one");
   });
 
   test("passes source function through", async () => {
     const sourceFn = mock(() => [{ name: "X", value: "x" }]);
-    mockSearch.mockResolvedValueOnce("x");
+    mockSearchCancellable.mockResolvedValueOnce("x");
 
     await Sprinkle.SearchSelect({
       message: "Search",
       source: sourceFn,
     });
 
-    expect(mockSearch.mock.calls[0][0].source).toBe(sourceFn);
+    expect(mockSearchCancellable.mock.calls[0][0].source).toBe(sourceFn);
+  });
+
+  test("returns null when cancelled", async () => {
+    mockSearchCancellable.mockResolvedValueOnce(null);
+
+    const result = await Sprinkle.SearchSelect({
+      message: "Pick one",
+      source: () => [{ name: "A", value: "a" }],
+    });
+
+    expect(result).toBeNull();
   });
 });
 
@@ -120,6 +144,8 @@ describe("Optional type support (2.4)", () => {
     sprinkle = new Sprinkle(schema, "/tmp/test");
     mockSelect.mockClear();
     mockInput.mockClear();
+    mockSelectCancellable.mockClear();
+    mockInputCancellable.mockClear();
   });
 
   test("skips optional field when user selects Skip", async () => {
@@ -128,8 +154,8 @@ describe("Optional type support (2.4)", () => {
       nickname: Type.Optional(Type.String()),
     });
 
-    mockInput.mockResolvedValueOnce("Alice"); // name
-    mockSelect.mockResolvedValueOnce(false); // skip nickname
+    mockInputCancellable.mockResolvedValueOnce("Alice"); // name
+    mockSelectCancellable.mockResolvedValueOnce(false); // skip nickname
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result.name).toBe("Alice");
@@ -142,10 +168,10 @@ describe("Optional type support (2.4)", () => {
       nickname: Type.Optional(Type.String()),
     });
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("Alice") // name
       .mockResolvedValueOnce("Ali"); // nickname
-    mockSelect.mockResolvedValueOnce(true); // fill nickname
+    mockSelectCancellable.mockResolvedValueOnce(true); // fill nickname
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result.name).toBe("Alice");

package/src/Sprinkle/__tests__/fill-in-struct.test.ts

@@ -1,11 +1,16 @@
 import { describe, expect, test, mock, beforeEach, spyOn } from "bun:test";
 import { Sprinkle, Type, WalletSettingsSchema } from "../index.js";
+import { UserCancelledError } from "../types.js";
 
 // Mock @inquirer/prompts
 const mockSelect = mock();
 const mockInput = mock();
 const mockPassword = mock();
 const mockConfirm = mock();
+const mockSelectCancellable = mock();
+const mockInputCancellable = mock();
+const mockPasswordCancellable = mock();
+const mockConfirmCancellable = mock();
 
 mock.module("@inquirer/prompts", () => ({
   select: mockSelect,
@@ -14,6 +19,13 @@ mock.module("@inquirer/prompts", () => ({
   confirm: mockConfirm,
 }));
 
+mock.module("../prompts.js", () => ({
+  selectCancellable: mockSelectCancellable,
+  inputCancellable: mockInputCancellable,
+  passwordCancellable: mockPasswordCancellable,
+  confirmCancellable: mockConfirmCancellable,
+}));
+
 describe("FillInStruct", () => {
   let sprinkle: Sprinkle<any>;
 
@@ -22,24 +34,30 @@ describe("FillInStruct", () => {
     sprinkle = new Sprinkle(schema, "/tmp/test");
     mockSelect.mockClear();
     mockInput.mockClear();
+    mockPassword.mockClear();
+    mockConfirm.mockClear();
+    mockSelectCancellable.mockClear();
+    mockInputCancellable.mockClear();
+    mockPasswordCancellable.mockClear();
+    mockConfirmCancellable.mockClear();
   });
 
   test("fills a simple string field", async () => {
-    mockInput.mockResolvedValueOnce("hello");
+    mockInputCancellable.mockResolvedValueOnce("hello");
 
     const result = await sprinkle.FillInStruct(Type.String());
     expect(result).toBe("hello");
   });
 
   test("fills a string with title as prompt", async () => {
-    mockInput.mockResolvedValueOnce("world");
+    mockInputCancellable.mockResolvedValueOnce("world");
 
     await sprinkle.FillInStruct(Type.String({ title: "Enter name" }));
-    expect(mockInput.mock.calls[0][0].message).toBe("Enter name");
+    expect(mockInputCancellable.mock.calls[0][0].message).toBe("Enter name");
   });
 
   test("fills a bigint field", async () => {
-    mockInput.mockResolvedValueOnce("42");
+    mockInputCancellable.mockResolvedValueOnce("42");
 
     const result = await sprinkle.FillInStruct(Type.BigInt());
     expect(result).toBe(42n);
@@ -48,8 +66,8 @@ describe("FillInStruct", () => {
   test("fills a literal field without prompting", async () => {
     const result = await sprinkle.FillInStruct(Type.Literal("fixed"));
     expect(result).toBe("fixed");
-    expect(mockInput).not.toHaveBeenCalled();
-    expect(mockSelect).not.toHaveBeenCalled();
+    expect(mockInputCancellable).not.toHaveBeenCalled();
+    expect(mockSelectCancellable).not.toHaveBeenCalled();
   });
 
   test("fills an object with multiple fields", async () => {
@@ -58,7 +76,7 @@ describe("FillInStruct", () => {
       age: Type.BigInt(),
     });
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("Alice")
       .mockResolvedValueOnce("30");
 
@@ -79,10 +97,10 @@ describe("FillInStruct", () => {
     ]);
 
     // Select first variant (the Object with type "a")
-    mockSelect.mockImplementationOnce(async (opts: any) => {
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
       return opts.choices[0].value;
     });
-    mockInput.mockResolvedValueOnce("test-value");
+    mockInputCancellable.mockResolvedValueOnce("test-value");
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result).toEqual({ type: "a", value: "test-value" });
@@ -91,10 +109,10 @@ describe("FillInStruct", () => {
   test("fills an array with items", async () => {
     const schema = Type.Array(Type.String());
 
-    mockInput.mockResolvedValueOnce("first");
-    mockSelect.mockResolvedValueOnce(true); // add another
-    mockInput.mockResolvedValueOnce("second");
-    mockSelect.mockResolvedValueOnce(false); // stop
+    mockInputCancellable.mockResolvedValueOnce("first");
+    mockSelectCancellable.mockResolvedValueOnce(true); // add another
+    mockInputCancellable.mockResolvedValueOnce("second");
+    mockSelectCancellable.mockResolvedValueOnce(false); // stop
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result).toEqual(["first", "second"]);
@@ -103,30 +121,30 @@ describe("FillInStruct", () => {
   test("fills an array with single item", async () => {
     const schema = Type.Array(Type.String());
 
-    mockInput.mockResolvedValueOnce("only");
-    mockSelect.mockResolvedValueOnce(false); // stop
+    mockInputCancellable.mockResolvedValueOnce("only");
+    mockSelectCancellable.mockResolvedValueOnce(false); // stop
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result).toEqual(["only"]);
   });
 
   test("uses default value for string", async () => {
-    mockInput.mockResolvedValueOnce("used-default");
+    mockInputCancellable.mockResolvedValueOnce("used-default");
 
     await sprinkle.FillInStruct(
       Type.String(),
       "my-default" as any,
     );
 
-    expect(mockInput.mock.calls[0][0].default).toBe("my-default");
+    expect(mockInputCancellable.mock.calls[0][0].default).toBe("my-default");
   });
 
   test("uses default value for bigint", async () => {
-    mockInput.mockResolvedValueOnce("99");
+    mockInputCancellable.mockResolvedValueOnce("99");
 
     await sprinkle.FillInStruct(Type.BigInt(), 99n as any);
 
-    expect(mockInput.mock.calls[0][0].default).toBe("99");
+    expect(mockInputCancellable.mock.calls[0][0].default).toBe("99");
   });
 
   test("throws for unsupported types", async () => {
@@ -142,14 +160,14 @@ describe("FillInStruct", () => {
       }),
     });
 
-    mockInput.mockResolvedValueOnce("deep-value");
+    mockInputCancellable.mockResolvedValueOnce("deep-value");
 
     const result = await sprinkle.FillInStruct(schema);
     expect(result).toEqual({ outer: { inner: "deep-value" } });
   });
 
   test("remembers last string input as default", async () => {
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("first-input")
       .mockResolvedValueOnce("second-input");
 
@@ -158,13 +176,13 @@ describe("FillInStruct", () => {
 
     await sprinkle.FillInStruct(Type.String());
     // Second call should have the first input as default
-    expect(mockInput.mock.calls[1][0].default).toBe("first-input");
+    expect(mockInputCancellable.mock.calls[1][0].default).toBe("first-input");
   });
 
   test("fills a tuple with same-type elements", async () => {
     const schema = Type.Tuple([Type.String(), Type.String()]);
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("policyId")
       .mockResolvedValueOnce("assetName");
 
@@ -175,7 +193,7 @@ describe("FillInStruct", () => {
   test("fills a tuple with mixed types", async () => {
     const schema = Type.Tuple([Type.String(), Type.BigInt()]);
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("label")
       .mockResolvedValueOnce("42");
 
@@ -186,14 +204,14 @@ describe("FillInStruct", () => {
   test("fills a tuple with default values", async () => {
     const schema = Type.Tuple([Type.String(), Type.BigInt()]);
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("new-label")
       .mockResolvedValueOnce("99");
 
     await sprinkle.FillInStruct(schema, ["default-label", 50n] as any);
 
-    expect(mockInput.mock.calls[0][0].default).toBe("default-label");
-    expect(mockInput.mock.calls[1][0].default).toBe("50");
+    expect(mockInputCancellable.mock.calls[0][0].default).toBe("default-label");
+    expect(mockInputCancellable.mock.calls[1][0].default).toBe("50");
   });
 
   test("fills a tuple nested in an object", async () => {
@@ -201,7 +219,7 @@ describe("FillInStruct", () => {
       asset: Type.Tuple([Type.String(), Type.String()]),
     });
 
-    mockInput
+    mockInputCancellable
       .mockResolvedValueOnce("policy123")
       .mockResolvedValueOnce("token456");
 
@@ -213,14 +231,14 @@ describe("FillInStruct", () => {
     const schema = Type.String({ title: "Hot Wallet Private Key" });
 
     // Select "existing" option
-    mockSelect.mockResolvedValueOnce("existing");
-    mockPassword.mockResolvedValueOnce("my-private-key");
+    mockSelectCancellable.mockResolvedValueOnce("existing");
+    mockPasswordCancellable.mockResolvedValueOnce("my-private-key");
 
     const result = await sprinkle.FillInStruct(schema);
 
     // Verify select was called with correct options
-    expect(mockSelect.mock.calls[0][0].message).toBe("Hot wallet setup:");
-    expect(mockSelect.mock.calls[0][0].choices).toEqual([
+    expect(mockSelectCancellable.mock.calls[0][0].message).toBe("Hot wallet setup:");
+    expect(mockSelectCancellable.mock.calls[0][0].choices).toEqual([
       { name: "Enter existing private key", value: "existing" },
       { name: "Generate new wallet", value: "generate" },
     ]);
@@ -230,12 +248,12 @@ describe("FillInStruct", () => {
   test("hot wallet existing key prompts for password", async () => {
     const schema = Type.String({ title: "Hot Wallet Private Key" });
 
-    mockSelect.mockResolvedValueOnce("existing");
-    mockPassword.mockResolvedValueOnce("deadbeef1234");
+    mockSelectCancellable.mockResolvedValueOnce("existing");
+    mockPasswordCancellable.mockResolvedValueOnce("deadbeef1234");
 
     const result = await sprinkle.FillInStruct(schema);
 
-    expect(mockPassword).toHaveBeenCalledWith({
+    expect(mockPasswordCancellable).toHaveBeenCalledWith({
       message: "Enter your private key:",
     });
     expect(result).toBe("deadbeef1234");
@@ -243,12 +261,12 @@ describe("FillInStruct", () => {
 
   test("full wallet settings schema with existing key", async () => {
     // Select "hot" variant
-    mockSelect.mockImplementationOnce(async (opts: any) => {
+    mockSelectCancellable.mockImplementationOnce(async (opts: any) => {
       return opts.choices[0].value; // hot wallet object
     });
     // Select "existing" key option
-    mockSelect.mockResolvedValueOnce("existing");
-    mockPassword.mockResolvedValueOnce("abc123privatekey");
+    mockSelectCancellable.mockResolvedValueOnce("existing");
+    mockPasswordCancellable.mockResolvedValueOnce("abc123privatekey");
 
     const result = await sprinkle.FillInStruct(WalletSettingsSchema);
 
@@ -257,4 +275,52 @@ describe("FillInStruct", () => {
       privateKey: "abc123privatekey",
     });
   });
+
+  test("throws UserCancelledError when input prompt is cancelled", async () => {
+    mockInputCancellable.mockResolvedValueOnce(null);
+
+    await expect(sprinkle.FillInStruct(Type.String())).rejects.toThrow(
+      UserCancelledError,
+    );
+  });
+
+  test("throws UserCancelledError when select prompt is cancelled", async () => {
+    const schema = Type.Union([
+      Type.Object({ type: Type.Literal("a") }),
+      Type.Object({ type: Type.Literal("b") }),
+    ]);
+
+    mockSelectCancellable.mockResolvedValueOnce(null);
+
+    await expect(sprinkle.FillInStruct(schema)).rejects.toThrow(
+      UserCancelledError,
+    );
+  });
+
+  test("throws UserCancelledError when nested prompt is cancelled", async () => {
+    const schema = Type.Object({
+      name: Type.String(),
+      age: Type.BigInt(),
+    });
+
+    // First field succeeds, second is cancelled
+    mockInputCancellable
+      .mockResolvedValueOnce("Alice")
+      .mockResolvedValueOnce(null);
+
+    await expect(sprinkle.FillInStruct(schema)).rejects.toThrow(
+      UserCancelledError,
+    );
+  });
+
+  test("throws UserCancelledError when array add-another prompt is cancelled", async () => {
+    const schema = Type.Array(Type.String());
+
+    mockInputCancellable.mockResolvedValueOnce("first");
+    mockSelectCancellable.mockResolvedValueOnce(null); // cancel on "add another?"
+
+    await expect(sprinkle.FillInStruct(schema)).rejects.toThrow(
+      UserCancelledError,
+    );
+  });
 });

package/src/Sprinkle/__tests__/settings-persistence.test.ts

@@ -178,4 +178,112 @@ describe("Settings Persistence", () => {
     expect(sprinkle.defaults).toEqual({ string: "old" });
     expect(sprinkle.profileMeta.name).toBe("Default");
   });
+
+  describe("currentProfile", () => {
+    test("returns null when no profile loaded", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = new Sprinkle(schema, tmpDir);
+
+      expect(sprinkle.currentProfile).toBeNull();
+    });
+
+    test("returns profile info when loaded", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+
+      const profile = sprinkle.currentProfile;
+      expect(profile).not.toBeNull();
+      expect(profile!.id).toBe("test");
+      expect(profile!.name).toBe("Test");
+      expect(profile!.createdAt).toBeDefined();
+      expect(profile!.updatedAt).toBeDefined();
+    });
+
+    test("includes description when present", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.profileMeta.description = "Test profile description";
+
+      const profile = sprinkle.currentProfile;
+      expect(profile!.description).toBe("Test profile description");
+    });
+
+    test("has undefined description when not set", () => {
+      const schema = Type.Object({ name: Type.String() });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      delete sprinkle.profileMeta.description;
+
+      const profile = sprinkle.currentProfile;
+      expect(profile!.description).toBeUndefined();
+    });
+  });
+
+  describe("getDisplaySettings", () => {
+    test("masks sensitive fields", () => {
+      const schema = Type.Object({
+        name: Type.String(),
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { name: "visible", secret: "hidden" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.name).toBe("visible");
+      expect(display.secret).toBe("********");
+    });
+
+    test("preserves non-sensitive fields", () => {
+      const schema = Type.Object({
+        name: Type.String(),
+        count: Type.Number(),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { name: "test", count: 42 } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.name).toBe("test");
+      expect(display.count).toBe(42);
+    });
+
+    test("preserves BigInt values", () => {
+      const schema = Type.Object({
+        amount: Type.BigInt(),
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { amount: 42n, secret: "hidden" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.amount).toBe(42n);
+      expect(display.secret).toBe("********");
+    });
+
+    test("masks nested sensitive fields", () => {
+      const schema = Type.Object({
+        wallet: Type.Object({
+          key: Type.String({ sensitive: true }),
+          address: Type.String(),
+        }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = {
+        wallet: { key: "secret", address: "addr1..." },
+      } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.wallet.key).toBe("********");
+      expect(display.wallet.address).toBe("addr1...");
+    });
+
+    test("does not mask empty sensitive fields", () => {
+      const schema = Type.Object({
+        secret: Type.String({ sensitive: true }),
+      });
+      const sprinkle = withProfile(new Sprinkle(schema, tmpDir));
+      sprinkle.settings = { secret: "" } as any;
+
+      const display = sprinkle.getDisplaySettings();
+      expect(display.secret).toBe("");
+    });
+  });
 });