akanjs 2.2.4 → 2.2.5

package/common/routeConvention.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  assertUniqueRoutePatterns,
-  compareRouteSpecificity,
-  isRouteSourceFile,
-  matchRoutePattern,
-  parseRouteModuleKey,
-  validatePageSourceFile,
-  validateSubRoutePageKey,
-} from "./routeConvention";
-
-describe("route convention", () => {
-  test("parses leaf, index, layout, route groups, and dynamic segments", () => {
-    expect(parseRouteModuleKey("./akanjs.tsx")).toMatchObject({
-      kind: "page",
-      routeSegments: ["[lang]", "akanjs"],
-      sourceRouteSegments: ["akanjs"],
-      pattern: "/:lang/akanjs",
-    });
-    expect(parseRouteModuleKey("./(user)/cluster/[clusterId]/_index.tsx")).toMatchObject({
-      kind: "page",
-      routeSegments: ["[lang]", "(user)", "cluster", "[clusterId]"],
-      sourceRouteSegments: ["(user)", "cluster", "[clusterId]"],
-      pattern: "/:lang/cluster/:clusterId",
-    });
-    expect(parseRouteModuleKey("./akanjs/_layout.tsx")).toMatchObject({
-      kind: "layout",
-      routeSegments: ["[lang]", "akanjs"],
-      sourceRouteSegments: ["akanjs"],
-      pattern: "/:lang/akanjs",
-    });
-    expect(parseRouteModuleKey("./_layout.tsx")).toMatchObject({
-      kind: "layout",
-      routeSegments: ["[lang]"],
-      sourceRouteSegments: [],
-      pattern: "/:lang",
-    });
-    expect(parseRouteModuleKey("./akan/__root_layout.tsx")).toMatchObject({
-      kind: "layout",
-      routeSegments: ["[lang]", "akan"],
-      sourceRouteSegments: ["akan"],
-      pattern: "/:lang/akan",
-      isInternalRootLayout: true,
-    });
-  });
-
-  test("rejects unsupported reserved and catch-all route files", () => {
-    expect(() => parseRouteModuleKey("./_helper.ts")).toThrow("unsupported reserved route file");
-    expect(() => parseRouteModuleKey("./[lang]/foo.tsx")).toThrow("Akan.js injects `[lang]` automatically");
-    expect(() => parseRouteModuleKey("./[...slug].tsx")).toThrow("catch-all routes are not supported");
-    expect(() => parseRouteModuleKey("./[[...slug]].tsx")).toThrow("catch-all routes are not supported");
-  });
-
-  test("detects leaf pages as route source files", () => {
-    expect(isRouteSourceFile("docs/intro/quickstart.tsx")).toBe(true);
-    expect(isRouteSourceFile("(docs)/docs/intro/[slug].tsx")).toBe(true);
-    expect(isRouteSourceFile("docs/intro/_index.tsx")).toBe(true);
-    expect(isRouteSourceFile("docs/intro/_layout.tsx")).toBe(true);
-    expect(isRouteSourceFile("docs/intro/_helper.tsx")).toBe(false);
-    expect(isRouteSourceFile("docs/[...slug].tsx")).toBe(false);
-  });
-
-  test("validates page source file conventions", () => {
-    for (const file of [
-      "docs/intro/_index.tsx",
-      "docs/intro/_layout.tsx",
-      "docs/intro/foo.tsx",
-      "docs/intro/[id].tsx",
-      "robots.txt.tsx",
-    ]) {
-      expect(validatePageSourceFile(file)).toBe(true);
-    }
-    expect(validatePageSourceFile("docs/intro/style.css")).toBe(false);
-    expect(() => validatePageSourceFile("docs/intro/logic.ts")).toThrow("must use .tsx");
-    expect(() => validatePageSourceFile("docs/intro/Component.tsx")).toThrow("uppercase letter");
-    expect(() => validatePageSourceFile("docs/intro/_Component.tsx")).toThrow("reserved route files");
-    expect(() => validatePageSourceFile("docs/intro/_helper.tsx")).toThrow("reserved route files");
-  });
-
-  test("keeps robots outside implicit locale", () => {
-    expect(parseRouteModuleKey("./robots.txt.tsx")).toMatchObject({
-      kind: "page",
-      routeSegments: ["robots.txt"],
-      pattern: "/robots.txt",
-      isSpecialRoute: true,
-    });
-  });
-
-  test("removed special route leaves use implicit locale", () => {
-    expect(parseRouteModuleKey("./opengraph-image.tsx")).toMatchObject({
-      routeSegments: ["[lang]", "opengraph-image"],
-      pattern: "/:lang/opengraph-image",
-      isSpecialRoute: false,
-    });
-    expect(parseRouteModuleKey("./manifest.json.tsx")).toMatchObject({
-      routeSegments: ["[lang]", "manifest.json"],
-      pattern: "/:lang/manifest.json",
-      isSpecialRoute: false,
-    });
-  });
-
-  test("detects route conflicts", () => {
-    expect(() =>
-      assertUniqueRoutePatterns([
-        { key: "./foo.tsx", pattern: "/foo" },
-        { key: "./foo/_index.tsx", pattern: "/foo" },
-      ]),
-    ).toThrow("route conflict");
-  });
-
-  test("validates subRoute page keys when basePaths are configured", () => {
-    expect(() => validateSubRoutePageKey("./_layout.tsx", [])).not.toThrow();
-    expect(() => validateSubRoutePageKey("./foo.tsx", [])).not.toThrow();
-    expect(() => validateSubRoutePageKey("./akanjs/_index.tsx", ["akanjs", "soft"])).not.toThrow();
-    expect(() => validateSubRoutePageKey("./soft/(tab)/_layout.tsx", ["akanjs", "soft"])).not.toThrow();
-
-    for (const key of ["./_layout.tsx", "./_index.tsx", "./foo.tsx", "./robots.txt.tsx", "./admin/_index.tsx"]) {
-      expect(() => validateSubRoutePageKey(key, ["akanjs", "soft"], { appName: "akan" })).toThrow(
-        'app "akan" uses subRoutes (akanjs, soft)',
-      );
-    }
-  });
-
-  test("matches and sorts route patterns by specificity", () => {
-    expect(matchRoutePattern("/:lang/cluster/:clusterId", "/ko/cluster/abc")).toEqual({
-      lang: "ko",
-      clusterId: "abc",
-    });
-    expect(["/:lang/:id", "/:lang/new"].sort(compareRouteSpecificity)).toEqual(["/:lang/new", "/:lang/:id"]);
-  });
-});

package/common/runtimeConfig.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  DEFAULT_AKAN_I18N,
-  getAkanHmrPhase,
-  getBasePathFromPathname,
-  isAkanHmrApplying,
-  parseAkanI18nEnv,
-  parseBasePaths,
-  randomPick,
-  randomPicks,
-  resolveAkanI18nConfig,
-} from ".";
-
-describe("runtime config helpers", () => {
-  test("normalizes i18n config and validates default locale membership", () => {
-    expect(DEFAULT_AKAN_I18N).toEqual({ defaultLocale: "en", locales: ["en", "ko"] });
-    expect(resolveAkanI18nConfig({ defaultLocale: "ko", locales: [" en ", "ko", "ko"] })).toEqual({
-      defaultLocale: "ko",
-      locales: ["en", "ko"],
-    });
-    expect(() => resolveAkanI18nConfig({ defaultLocale: "ja", locales: ["en", "ko"] })).toThrow(
-      '[i18n] defaultLocale "ja" must be included in locales: en,ko',
-    );
-    expect(() => resolveAkanI18nConfig({ locales: [" "] })).toThrow("[i18n] locales must include at least one locale");
-  });
-
-  test("parses i18n environment values", () => {
-    expect(
-      parseAkanI18nEnv({
-        AKAN_PUBLIC_DEFAULT_LOCALE: "ko",
-        AKAN_PUBLIC_LOCALES: "en,ko,ja",
-      }),
-    ).toEqual({ defaultLocale: "ko", locales: ["en", "ko", "ja"] });
-  });
-
-  test("parses and detects configured base paths", () => {
-    expect(parseBasePaths("akanjs, soft,akanjs,,")).toEqual(["akanjs", "soft"]);
-    expect(parseBasePaths(new Set(["akan", "akan", "admin"]))).toEqual(["akan", "admin"]);
-
-    const options = {
-      basePaths: ["akanjs", "soft"],
-      i18n: { defaultLocale: "en", locales: ["en", "ko"] },
-    };
-
-    expect(getBasePathFromPathname("/ko/akanjs/home", options)).toBe("akanjs");
-    expect(getBasePathFromPathname("/soft/home", options)).toBe("soft");
-    expect(getBasePathFromPathname("/ko/unknown/home", options)).toBeNull();
-    expect(getBasePathFromPathname("/unknown/home", { ...options, headerBasePath: "akanjs" })).toBe("akanjs");
-    expect(getBasePathFromPathname("/unknown/home", { ...options, headerBasePath: "unknown" })).toBeNull();
-  });
-
-  test("reads Akan HMR phase from globalThis", () => {
-    const previousPhase = globalThis.__AKAN_HMR_PHASE__;
-
-    try {
-      globalThis.__AKAN_HMR_PHASE__ = undefined;
-      expect(getAkanHmrPhase()).toBeNull();
-      expect(isAkanHmrApplying()).toBe(false);
-
-      globalThis.__AKAN_HMR_PHASE__ = "refresh-import";
-      expect(getAkanHmrPhase()).toBe("refresh-import");
-      expect(isAkanHmrApplying()).toBe(true);
-
-      globalThis.__AKAN_HMR_PHASE__ = "react-refresh";
-      expect(getAkanHmrPhase()).toBe("react-refresh");
-    } finally {
-      globalThis.__AKAN_HMR_PHASE__ = previousPhase;
-    }
-  });
-
-  test("random helpers pick values from the input collection", () => {
-    const previousRandom = Math.random;
-    Math.random = () => 0.5;
-
-    try {
-      expect(randomPick(["a", "b", "c"])).toBe("b");
-      expect(randomPicks(["a", "b", "c"], 2, true)).toEqual(["b", "b"]);
-      expect(randomPicks(["a", "b"], 3, false)).toEqual(["a", "b"]);
-    } finally {
-      Math.random = previousRandom;
-    }
-  });
-});

package/constant/constant.test.ts

@@ -1,374 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { dayjs, enumOf, FIELD_META, ID, Int, type PrimitiveScalar } from "akanjs/base";
-import { immerable } from "immer";
-import { ConstantField, ConstantRegistry, deserialize, immerify, serialize, via } from ".";
-
-const Role = enumOf("ConstantTestRole", ["admin", "user"] as const);
-
-const CoordinateInput = via((f) => ({
-  lat: f(Int, { default: 37 }),
-  lng: f(Int, { default: 127 }),
-}));
-ConstantRegistry.buildScalar("constantTestCoordinate", CoordinateInput, { CoordinateInput });
-
-const AddressInput = via((f) => ({
-  city: f(String),
-  zip: f(Int, { default: 10000 }),
-  coordinate: f(CoordinateInput),
-}));
-ConstantRegistry.buildScalar("constantTestAddress", AddressInput, { AddressInput });
-
-const ComplexInput = via((f) => ({
-  settings: f(Map, { of: String }),
-  cube: f([[[[Int]]]] as never),
-  addressCube: f([[[AddressInput]]] as never),
-  primaryAddress: f(AddressInput),
-  addressBook: f(Map, { of: AddressInput as unknown as typeof PrimitiveScalar }),
-}));
-ConstantRegistry.buildScalar("constantTestComplex", ComplexInput, { ComplexInput });
-
-const UserInput = via((f) => ({
-  name: f(String),
-  age: f(Int, { default: 20 }),
-  role: f(String, { default: "user" }),
-  tags: f([String]),
-  metadata: f(Map, { of: String }),
-  password: f.secret(String),
-}));
-const UserObject = via(UserInput, (f) => ({
-  note: f(String).optional(),
-}));
-const UserLight = via(UserObject, ["name", "role"] as const, (r) => ({
-  profileText: r(String, { text: "search" }),
-}));
-const UserFull = via(UserObject, UserLight, (r) => ({
-  addressLabel: r(String, { text: "filter" }),
-}));
-const UserInsight = via(UserFull, (f) => ({
-  activeCount: f(Int, { default: 0, accumulate: { role: "admin" } }),
-}));
-const userModel = ConstantRegistry.buildModel(
-  "constantTestUser",
-  UserInput,
-  UserObject,
-  UserFull,
-  UserLight,
-  UserInsight,
-  { UserInput, UserObject, UserFull, UserLight, UserInsight, Role, statusLabel: "active" },
-);
-
-const TeamInput = via((f) => ({
-  owner: f(UserLight),
-  members: f([UserLight]),
-}));
-const TeamObject = via(TeamInput, (f) => ({
-  title: f(String),
-}));
-const TeamLight = via(TeamObject, ["owner", "members", "title"] as const, (r) => ({}));
-const TeamFull = via(TeamObject, TeamLight, (r) => ({}));
-const TeamInsight = via(TeamFull, (f) => ({}));
-ConstantRegistry.buildModel("constantTestTeam", TeamInput, TeamObject, TeamFull, TeamLight, TeamInsight, {
-  TeamInput,
-  TeamObject,
-  TeamFull,
-  TeamLight,
-  TeamInsight,
-});
-
-const validUserId = "1234567890abcdef12345678";
-const validChildId = "abcdefabcdefabcdefabcdef";
-const complexInput = (input: Record<string, unknown>) => input as never;
-
-const createUser = () =>
-  new UserFull({
-    id: validUserId,
-    name: "Ada",
-    age: 31,
-    role: "admin",
-    tags: ["founder", "engineer"],
-    metadata: { locale: "ko" } as never,
-    password: "secret",
-    note: "hello",
-    profileText: "Ada profile",
-    addressLabel: "Seoul",
-    createdAt: "2026-01-01T00:00:00.000Z" as never,
-    updatedAt: "2026-01-02T00:00:00.000Z" as never,
-  });
-
-describe("via and ConstantField", () => {
-  test("builds field metadata and default values", () => {
-    expect(UserInput.modelType).toBe("input");
-    expect(UserObject.modelType).toBe("object");
-    expect(UserLight.modelType).toBe("light");
-    expect(UserFull.modelType).toBe("full");
-    expect(UserInsight.modelType).toBe("insight");
-
-    const nameField = UserFull[FIELD_META].name;
-    const metadataField = UserFull[FIELD_META].metadata;
-    const passwordField = UserFull[FIELD_META].password;
-
-    expect(nameField).toBeInstanceOf(ConstantField);
-    expect(nameField.modelRef).toBe(String);
-    expect(metadataField.isMap).toBe(true);
-    expect(metadataField.of).toBe(String);
-    expect(passwordField.fieldType).toBe("hidden");
-    expect(passwordField.select).toBe(false);
-
-    expect(UserFull.getDefault()).toMatchObject({
-      name: "",
-      age: 20,
-      role: "user",
-      tags: [],
-      metadata: undefined,
-      note: null,
-      addressLabel: "",
-      password: null,
-    });
-    expect(UserFull.text.search.has("profileText")).toBe(true);
-    expect(UserFull.text.filter.has("addressLabel")).toBe(true);
-  });
-
-  test("crystalizes constructor input into typed runtime values", () => {
-    const user = createUser();
-
-    expect(user.createdAt.toISOString()).toBe(dayjs("2026-01-01T00:00:00.000Z").toISOString());
-    expect(user.metadata).toBeInstanceOf(Map);
-    expect(user.metadata.get("locale")).toBe("ko");
-
-    user.set({ age: 32 });
-
-    expect(user.age).toBe(32);
-
-    const address = new AddressInput({ city: "Seoul" } as never);
-    expect(address.city).toBe("Seoul");
-    expect(address.zip).toBe(10000);
-  });
-
-  test("supports maps, deep nested objects, and high-dimensional arrays", () => {
-    const cube = [
-      [
-        [
-          [1, 2],
-          [3, 4],
-        ],
-      ],
-    ];
-    const addressCube = [
-      [
-        [
-          { city: "Seoul", zip: 12345, coordinate: { lat: 37, lng: 127 } },
-          { city: "Busan", zip: 23456, coordinate: { lat: 35, lng: 129 } },
-        ],
-      ],
-    ];
-    const complex = new ComplexInput(
-      complexInput({
-        settings: { theme: "dark", locale: "ko" } as never,
-        cube,
-        addressCube,
-        primaryAddress: { city: "Jeju", coordinate: { lat: 33, lng: 126 } },
-        addressBook: {
-          home: { city: "Seoul", zip: 12345, coordinate: { lat: 37, lng: 127 } },
-          office: { city: "Pangyo", coordinate: { lat: 37, lng: 127 } },
-        } as never,
-      }),
-    );
-    const cubeField = ComplexInput[FIELD_META].cube;
-    const addressCubeField = ComplexInput[FIELD_META].addressCube;
-    const primaryAddressField = ComplexInput[FIELD_META].primaryAddress;
-    const addressBookField = ComplexInput[FIELD_META].addressBook;
-
-    expect(cubeField.arrDepth).toBe(4);
-    expect(cubeField.modelRef).toBe(Int as unknown as typeof cubeField.modelRef);
-    expect(addressCubeField.arrDepth).toBe(3);
-    expect(addressCubeField.modelRef).toBe(AddressInput as unknown as typeof addressCubeField.modelRef);
-    expect(addressCubeField.isScalar).toBe(true);
-    expect(primaryAddressField.isClass).toBe(true);
-    expect(primaryAddressField.isScalar).toBe(true);
-    expect(addressBookField.isMap).toBe(true);
-    expect(addressBookField.of).toBe(AddressInput as unknown as typeof addressBookField.of);
-
-    const complexValue = complex as {
-      settings: Map<string, string>;
-      cube: number[][][][];
-      primaryAddress: InstanceType<typeof AddressInput>;
-      addressCube: InstanceType<typeof AddressInput>[][][];
-      addressBook: Map<string, InstanceType<typeof AddressInput>>;
-    };
-    expect(complexValue.settings).toBeInstanceOf(Map);
-    expect(complexValue.settings.get("theme")).toBe("dark");
-    expect(complexValue.cube).toEqual(cube);
-    expect(complexValue.primaryAddress).toBeInstanceOf(AddressInput);
-    expect(complexValue.primaryAddress.coordinate).toBeInstanceOf(CoordinateInput);
-    expect(complexValue.primaryAddress.zip).toBe(10000);
-    expect(complexValue.addressCube[0][0][1]).toBeInstanceOf(AddressInput);
-    expect(complexValue.addressCube[0][0][1].coordinate.lat).toBe(35);
-    expect(complexValue.addressBook).toBeInstanceOf(Map);
-    expect(complexValue.addressBook.get("office")?.zip).toBe(10000);
-  });
-});
-
-describe("ConstantRegistry", () => {
-  test("registers model refs and resolves model names", () => {
-    expect(ConstantRegistry.getDatabase("constantTestUser")).toBe(userModel);
-    expect(ConstantRegistry.getScalar("constantTestAddress").model).toBe(AddressInput as never);
-    expect(ConstantRegistry.getRefName(UserFull)).toBe("constantTestUser");
-    expect(ConstantRegistry.getModelName(UserInput)).toBe("ConstantTestUserInput");
-    expect(ConstantRegistry.getModelName(UserObject)).toBe("ConstantTestUserObject");
-    expect(ConstantRegistry.getModelName(UserLight)).toBe("LightConstantTestUser");
-    expect(ConstantRegistry.getModelName(UserFull)).toBe("ConstantTestUser");
-    expect(ConstantRegistry.getModelName(UserInsight)).toBe("ConstantTestUserInsight");
-    expect(ConstantRegistry.getModelName(ID)).toBe("ID");
-    expect(ConstantRegistry.value.get("statusLabel")).toBe("active");
-  });
-
-  test("serializes and deserializes primitive and model values", () => {
-    expect(ConstantRegistry.serialize(Int, 7 as never)).toBe(7 as never);
-    expect(ConstantRegistry.deserialize(Int, "7")).toBe(7 as never);
-
-    const user = createUser();
-    const serialized = ConstantRegistry.serialize(UserFull, user);
-
-    expect(serialized).toMatchObject({
-      id: validUserId,
-      name: "Ada",
-      age: 31,
-      role: "admin",
-      tags: ["founder", "engineer"],
-      metadata: { locale: "ko" },
-    });
-    expect(serialized.createdAt).toBeInstanceOf(Date);
-
-    const deserialized = ConstantRegistry.deserialize(UserFull, serialized);
-
-    expect(deserialized.createdAt.toISOString()).toBe(user.createdAt.toISOString());
-    expect(deserialized.metadata).toEqual({ locale: "ko" } as never);
-  });
-});
-
-describe("serialize, deserialize, purify, and immerify", () => {
-  test("handles arrays and nullable values", () => {
-    const serialized = serialize(String, 1, ["a", "b"], "object", {});
-    expect(serialized).toEqual(["a", "b"] as never);
-    expect(serialize(String, 0, null, "object", { nullable: true })).toBeNull();
-    expect(() => serialize(String, 0, null, "object", { key: "name" })).toThrow("Invalid Value (Nullable)");
-
-    expect(deserialize(String, 1, ["a", "b"], {})).toEqual(["a", "b"] as never);
-    expect(deserialize(String, 0, null, { nullable: true })).toBeNull();
-    expect(() => deserialize(String, 0, null, { key: "name" })).toThrow("Invalid Value (Nullable)");
-  });
-
-  test("serializes and deserializes complex schema shapes", () => {
-    const complex = new ComplexInput(
-      complexInput({
-        settings: { theme: "dark" } as never,
-        cube: [[[[1, 2, 3]]]],
-        addressCube: [[[{ city: "Seoul", coordinate: { lat: 37, lng: 127 } }]]],
-        primaryAddress: { city: "Jeju", coordinate: { lat: 33, lng: 126 } },
-        addressBook: {
-          home: { city: "Seoul", coordinate: { lat: 37, lng: 127 } },
-        } as never,
-      }),
-    );
-
-    const serialized = serialize(ComplexInput, 0, complex, "object", {});
-
-    expect(serialized).toMatchObject({
-      settings: { theme: "dark" },
-      cube: [[[[1, 2, 3]]]],
-      addressCube: [[[{ city: "Seoul", zip: 10000, coordinate: { lat: 37, lng: 127 } }]]],
-      primaryAddress: { city: "Jeju", zip: 10000, coordinate: { lat: 33, lng: 126 } },
-      addressBook: { home: { city: "Seoul", zip: 10000, coordinate: { lat: 37, lng: 127 } } },
-    });
-
-    const deserialized = deserialize(ComplexInput, 0, serialized, {}) as unknown as {
-      settings: Record<string, string>;
-      cube: number[][][][];
-      addressCube: { coordinate: { lat: number; lng: number } }[][][];
-      primaryAddress: { coordinate: { lng: number } };
-      addressBook: Record<string, { coordinate: { lng: number } }>;
-    };
-
-    expect(deserialized.settings).toEqual({ theme: "dark" });
-    expect(deserialized.cube).toEqual([[[[1, 2, 3]]]]);
-    expect(deserialized.addressCube[0][0][0].coordinate.lat).toBe(37);
-    expect(deserialized.primaryAddress.coordinate.lng).toBe(126);
-    expect(deserialized.addressBook.home.coordinate.lng).toBe(127);
-  });
-
-  test("preserves resolved relation objects when serializing response objects", () => {
-    const user = createUser();
-    const team = new TeamFull({
-      id: validChildId,
-      owner: user,
-      members: [user],
-      title: "Core",
-      createdAt: "2026-01-01T00:00:00.000Z" as never,
-      updatedAt: "2026-01-02T00:00:00.000Z" as never,
-    });
-
-    const objectSerialized = serialize(TeamFull, 0, team, "object", {}) as unknown as {
-      owner: { id: string; name: string };
-      members: { id: string; name: string }[];
-    };
-    const inputSerialized = serialize(TeamFull, 0, team, "input", {}) as unknown as {
-      owner: string;
-      members: string[];
-    };
-
-    expect(objectSerialized.owner).toMatchObject({ id: validUserId, name: "Ada" });
-    expect(objectSerialized.members[0]).toMatchObject({ id: validUserId, name: "Ada" });
-    expect(inputSerialized.owner).toBe(validUserId);
-    expect(inputSerialized.members).toEqual([validUserId]);
-  });
-
-  test("purifies valid input and rejects invalid values", () => {
-    const user = createUser();
-    const purified = UserFull.purify(user);
-
-    expect(purified).toMatchObject({
-      id: validUserId,
-      name: "Ada",
-      role: "admin",
-      metadata: { locale: "ko" },
-    });
-
-    expect(UserFull.purify({ ...UserFull.getDefault(), id: "bad-user" })).toBeNull();
-    expect(UserObject.purify({ id: validChildId } as never, true)).toBe(validChildId as never);
-    expect(() => UserObject.purify({} as never, true)).toThrow("Invalid Value (No ID)");
-  });
-
-  test("purifies complex schema shapes", () => {
-    const complex = new ComplexInput(
-      complexInput({
-        settings: { theme: "dark" } as never,
-        cube: [[[[1]]]],
-        addressCube: [[[{ city: "Seoul", coordinate: { lat: 37, lng: 127 } }]]],
-        primaryAddress: { city: "Jeju", coordinate: { lat: 33, lng: 126 } },
-        addressBook: {
-          home: { city: "Seoul", coordinate: { lat: 37, lng: 127 } },
-        } as never,
-      }),
-    );
-
-    expect(ComplexInput.purify(complex)).toMatchObject({
-      settings: { theme: "dark" },
-      cube: [[[[1]]]],
-      addressCube: [[[{ city: "Seoul", zip: 10000, coordinate: { lat: 37, lng: 127 } }]]],
-      primaryAddress: { city: "Jeju", zip: 10000, coordinate: { lat: 33, lng: 126 } },
-      addressBook: { home: { city: "Seoul", zip: 10000, coordinate: { lat: 37, lng: 127 } } },
-    });
-
-    expect(ComplexInput.purify({ ...ComplexInput.getDefault(), cube: [[1]] } as never)).toBeNull();
-  });
-
-  test("marks plain model objects as immerable recursively", () => {
-    const user = createUser();
-    const plain = serialize(UserFull, 0, user, "object", {}) as unknown as typeof user;
-    const immered = immerify(UserFull as never, plain);
-
-    expect((immered as unknown as Record<symbol, unknown>)[immerable]).toBe(true);
-    const address = immerify(AddressInput as never, { city: "Seoul", zip: 12345 });
-    expect((address as Record<symbol, unknown>)[immerable]).toBe(true);
-  });
-});