@terpjs/react-core 0.9.0 → 0.11.0

package/src/icons.tsx

@@ -1,3 +1,4 @@
+import type { IconName } from "@terpjs/contract";
 import type { ReactNode } from "react";
 
 import { injectTerpStyles } from "./styles";
@@ -27,8 +28,28 @@ const svgProps = {
   focusable: false,
 } as const;
 
-/** The bundled glyphs, keyed by the names a manifest's `NavItem.icon` may use. */
-export const ICON_GLYPHS: Record<string, ReactNode> = {
+// `IconName` must be the literal union, not `string`. Drop the `as const` from `ICON_NAMES` in
+// the contract and this directive becomes unused, which TypeScript reports as an error — which
+// is the point of writing it here rather than trusting the annotation over there. A scan cannot
+// check this, because the thing being checked is what the scan would be built out of.
+// @ts-expect-error the union must reject a name that is not in it
+const _iconNameIsNotWidened: IconName = "no-such-glyph";
+void _iconNameIsNotWidened;
+
+/**
+ * The bundled glyphs, keyed by the names a manifest's `NavItem.icon` may use.
+ *
+ * `satisfies Record<IconName, ReactNode>` is exhaustive in **both** directions at compile time:
+ * a glyph whose name is not in {@link ICON_NAMES} is an excess-property error, and a name with
+ * no glyph is a missing-property error. That is strictly stronger than the parity test ADR 0097
+ * §5 asked for — a test can only run after a build that already succeeded, and it would have to
+ * be kept in sync by hand — and it costs one keyword.
+ *
+ * The exported type stays `Record<string, ReactNode>` deliberately. `NavIcon` indexes this table
+ * with a `string` (its fallback is a designed behaviour, not an error), so narrowing the export
+ * would make that a type error at a call site the design wants to keep working.
+ */
+const GLYPHS = {
   home: (
     <svg {...svgProps}>
       <path d="M3 10.5 12 3l9 7.5" />
@@ -433,7 +454,34 @@ export const ICON_GLYPHS: Record<string, ReactNode> = {
       <path d="M13 3 4 14h6l-1 7 9-11h-6l1-7Z" />
     </svg>
   ),
-};
+  // The password reveal, and the only pair here where one glyph is the other struck through.
+  // The slash is part of `eye-off` rather than an overlay, so the two swap as whole glyphs and
+  // neither depends on the other rendering underneath it.
+  eye: (
+    <svg {...svgProps}>
+      <path d="M2 12s3.6-7 10-7 10 7 10 7-3.6 7-10 7-10-7-10-7Z" />
+      <circle cx="12" cy="12" r="3" />
+    </svg>
+  ),
+  "eye-off": (
+    <svg {...svgProps}>
+      <path d="M10.6 6.2A9.9 9.9 0 0 1 12 5c6.4 0 10 7 10 7a17.6 17.6 0 0 1-3.2 4.1" />
+      <path d="M6.6 6.8A17.7 17.7 0 0 0 2 12s3.6 7 10 7a9.8 9.8 0 0 0 4.5-1.1" />
+      <path d="M9.9 9.9a3 3 0 0 0 4.2 4.2" />
+      <path d="m3 3 18 18" />
+    </svg>
+  ),
+} satisfies Record<IconName, ReactNode>;
+
+/**
+ * The glyph table as the package publishes it.
+ *
+ * Typed as a string-keyed record rather than an IconName-keyed one, and that is not laziness:
+ * NavIcon looks a glyph up by a plain string on purpose, so a narrower index signature would
+ * break the one call site whose unknown-name behaviour is designed. The exhaustiveness lives on
+ * the declaration above, where it belongs.
+ */
+export const ICON_GLYPHS: Record<string, ReactNode> = GLYPHS;
 
 export interface NavIconProps {
   /** Glyph name (a `NavItem.icon` value); unknown / missing falls back to the initial. */
@@ -460,8 +508,22 @@ export function NavIcon({ name, label }: NavIconProps) {
 }
 
 export interface IconProps {
-  /** Glyph name from {@link ICON_GLYPHS}; unknown names render nothing. */
-  name: string;
+  /**
+   * Which glyph to render, by checked name.
+   *
+   * A checked name here and a plain `string` on {@link NavIconProps}, and the difference is the
+   * failure mode rather than the audience. `NavIcon` falls back to the label's initial in a
+   * tile — visible, designed, and gated by a specimen — so an unknown name there produces
+   * something. `Icon` rendered **nothing**: an empty box where a glyph should be, which is
+   * exactly the silent no-op this codebase refuses everywhere else.
+   *
+   * That was not hypothetical. The workbench's own icon gallery rendered
+   * `<Icon name="close" />` — there is no `close` glyph, the glyph is `x` — and shipped a blank
+   * cell with a caption under it. Its baseline recorded the blank and passed for releases,
+   * because a missing glyph and a glyph that is not there look identical. The type is what
+   * turns that into a build failure.
+   */
+  name: IconName;
   /**
    * CSS length applied to width & height (default `1em`, so the glyph tracks
    * the surrounding text size). All strokes use `currentColor`.

package/src/index.ts

@@ -23,11 +23,23 @@ export type {
 } from "./realtime";
 export { unwrap, unwrapOptional, ApiError } from "./unwrap";
 export type { FetchResult } from "./unwrap";
+export {
+  formatDate,
+  formatDateTime,
+  formatNumber,
+  useFormatDate,
+  useFormatDateTime,
+  useFormatNumber,
+} from "./format";
+export type { FormattableDate } from "./format";
 export { ResourceList } from "./ResourceList";
 export type { ResourceListProps } from "./ResourceList";
 export { RequireAuth } from "./RequireAuth";
 export type { RequireAuthProps } from "./RequireAuth";
-export { visibleNav } from "./nav";
+export { groupNav, isDeclarationVisible, visibleNav } from "./nav";
+export type { NavSection, NavVisibilityContext } from "./nav";
+export { activeNavPath, isNavItemActive } from "./navActive";
+export type { NavActiveCandidate } from "./navActive";
 export {
   AppShell,
   SIDEBAR_STORAGE_KEY,
@@ -51,6 +63,9 @@ export { Page } from "./Page";
 export type { PageProps } from "./Page";
 export { LAYOUT_CONTRACTS } from "./layoutContract";
 export type { LayoutContractSpec, LayoutSlotSpec } from "./layoutContract";
+// `ResolvedLayout` is deliberately NOT exported: nothing hands one to app code, so it
+// would be public surface a consumer can never hold.
+export type { LayoutDeclaration, LayoutShellDeclaration } from "./layoutDeclaration";
 export { PageActions } from "./PageActions";
 export type { OverflowAction, PageActionsProps } from "./PageActions";
 export { ModuleNav } from "./ModuleNav";
@@ -59,6 +74,17 @@ export { OverviewPage } from "./OverviewPage";
 export type { OverviewPageProps } from "./OverviewPage";
 export { DetailPage } from "./DetailPage";
 export type { DetailPageProps } from "./DetailPage";
+export { FormPage } from "./FormPage";
+export type { FormPageProps } from "./FormPage";
+export { SettingsPage } from "./SettingsPage";
+export type { SettingsPageProps } from "./SettingsPage";
+export { SplitPage, SplitPane } from "./SplitPage";
+export type {
+  SplitPageProps,
+  SplitPaneProps,
+  SplitPaneRole,
+  SplitListWidth,
+} from "./SplitPage";
 export { HubPage, HubCard } from "./HubPage";
 export type { HubPageProps, HubCardProps, RenderHubCardLink } from "./HubPage";
 export { UiTextProvider, useStrings, useUiText, resolveUiText, DEFAULT_STRINGS } from "./uiText";
@@ -76,11 +102,11 @@ export type { LoadingStateProps, InlineSpinnerProps } from "./LoadingState";
 export { ToastProvider, useToast } from "./toast";
 export type { ToastApi, ToastOptions, ToastProviderProps, ToastVariant } from "./toast";
 export { Button } from "./ui/Button";
-export type { ButtonProps, ButtonVariant } from "./ui/Button";
+export type { ButtonProps, ButtonSize, ButtonVariant } from "./ui/Button";
 export { Input } from "./ui/Input";
 export type { InputProps } from "./ui/Input";
 export { Select } from "./ui/Select";
-export type { SelectProps } from "./ui/Select";
+export type { SelectProps, SelectOption } from "./ui/Select";
 export { Textarea } from "./ui/Textarea";
 export type { TextareaProps } from "./ui/Textarea";
 export { Popover } from "./ui/Popover";
@@ -99,10 +125,12 @@ export { Switch } from "./ui/Switch";
 export type { SwitchProps } from "./ui/Switch";
 export { Tabs } from "./ui/Tabs";
 export type { TabItem, TabsProps } from "./ui/Tabs";
+export { Avatar } from "./ui/Avatar";
+export type { AvatarProps } from "./ui/Avatar";
 export { Badge } from "./ui/Badge";
 export type { BadgeProps, BadgeTone } from "./ui/Badge";
 export { Card } from "./ui/Card";
-export type { CardProps } from "./ui/Card";
+export type { CardProps, CardVariant } from "./ui/Card";
 export { Tooltip } from "./ui/Tooltip";
 export type { TooltipProps } from "./ui/Tooltip";
 export { Alert } from "./ui/Alert";
@@ -111,10 +139,32 @@ export { Markdown } from "./ui/Markdown";
 export type { MarkdownProps } from "./ui/Markdown";
 export { saveBlob, useEndpointDownload, fetchDownload, downloadUrl } from "./download";
 export type { DownloadTarget } from "./download";
+export { Heading, Text, Code, Link } from "./typography";
+export type {
+  HeadingProps,
+  HeadingLevel,
+  HeadingSize,
+  TextProps,
+  TextTone,
+  TextSize,
+  CodeProps,
+  LinkProps,
+} from "./typography";
 export { Field } from "./Field";
 export type { FieldProps } from "./Field";
-export { Stack, DetailList } from "./layout";
-export type { StackProps, DetailListProps, DetailItem, SpaceToken } from "./layout";
+export { Stack, Grid, Divider, DetailList } from "./layout";
+export type {
+  StackProps,
+  GridProps,
+  GridColumns,
+  GridMinColumn,
+  DividerProps,
+  Responsive,
+  DetailListProps,
+  DetailListLayout,
+  DetailItem,
+  SpaceToken,
+} from "./layout";
 export {
   buildAppRouter,
   DEFAULT_ROLE_RANKS,

package/src/layout.manifest.json

@@ -0,0 +1,118 @@
+{
+  "$comment": "The vocabulary of frontend/layout-contract.json as THIS release reads it — the standard's layout-declaration.schema.json with the per-stack value sets filled in. Published so a tool that edits an app's files can offer exactly the keys and values the app's own pinned framework will honour, rather than the ones the tool happens to know about; that inversion is the whole point, because an unknown key is refused at compose time rather than ignored. Hand-written rather than generated: every machine fact here — the keys at all three levels, the enums, the declared types, the emptiness floors, the required pair and the unknown-key refusals — mirrors a literal in layoutDeclaration.ts, themes.ts or layoutContract.ts, and layout.manifest.test.ts holds each of them to its source. The titles and descriptions are the part no generator could produce, and are held only to being present. The copy stays a copy, and the copy is checked.",
+  "title": "The app's layout declaration",
+  "description": "What this app declares once, in a file both its build-time checker and its running shell read. Every key is optional and an absent key is not a default: it is the app declining to declare, leaving whatever was already in force alone. Declaring a key here and passing the matching bootstrap option in code is refused when the router is composed.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "contract": {
+      "type": "string",
+      "minLength": 1,
+      "title": "Page contract",
+      "enum": [
+        "standard"
+      ],
+      "description": "Constrain every page archetype's body to the contract's own components, checked at lint time and again on the rendered page. Leaving it unset keeps archetype-only enforcement. Adopting one on an app that has none can turn a green build red, because it starts governing screens that were legal a moment earlier."
+    },
+    "defaultTheme": {
+      "type": "string",
+      "minLength": 1,
+      "title": "Starting palette",
+      "enum": [
+        "light",
+        "dark",
+        "midnight",
+        "twilight",
+        "contrast",
+        "system"
+      ],
+      "description": "The palette the app opens on, until a person picks another from the theme menu and for as long as they have not. \"system\" opens on whatever light or dark preference the viewer's own device reports."
+    },
+    "shell": {
+      "type": "object",
+      "additionalProperties": false,
+      "title": "Shell",
+      "description": "The frame around every page: how dense its controls are, where its navigation sits, how wide its content runs, and which groups that navigation is arranged into.",
+      "properties": {
+        "density": {
+          "type": "string",
+          "title": "Density",
+          "enum": [
+            "comfortable",
+            "compact"
+          ],
+          "description": "Control height and table cell padding for the whole app, from one attribute on the shell. Compact fits more rows on a screen; comfortable is easier to hit on a touch device."
+        },
+        "navPlacement": {
+          "type": "string",
+          "title": "Navigation placement",
+          "enum": [
+            "sidebar",
+            "header"
+          ],
+          "description": "Where the primary navigation sits on a wide screen: a full-height rail beside the content, or a row inside the header with no rail at all. On a narrow screen both become the same drawer."
+        },
+        "contentWidth": {
+          "type": "string",
+          "title": "Content width",
+          "enum": [
+            "full",
+            "measured"
+          ],
+          "description": "Whether a page's content runs the full width of the track or is capped at the shell's reading measure. Measured keeps long prose readable; full suits wide tables."
+        },
+        "brand": {
+          "type": "object",
+          "additionalProperties": false,
+          "title": "Brand mark",
+          "description": "The image your app is recognised by, shown beside its name in the header. Put the file in the app's frontend/public folder and name it here the way a browser would ask for it, starting with a slash.",
+          "properties": {
+            "logo": {
+              "type": "string",
+              "minLength": 1,
+              "title": "Mark",
+              "description": "The mark shown inside the app. It is sized to the header's own box, so a large file is scaled down rather than cut off."
+            },
+            "logoDark": {
+              "type": "string",
+              "minLength": 1,
+              "title": "Mark for dark palettes",
+              "description": "A second file for the dark palettes. Only worth setting when the first one has fixed colours that disappear on a dark background — most company marks do. Leave it empty and the same mark is used everywhere."
+            }
+          }
+        },
+        "navGroups": {
+          "type": "array",
+          "title": "Navigation groups",
+          "description": "The named sections the navigation is arranged into. A module's own navigation item points at one by id; an item naming a group that is not declared here is not an error, it simply lands in a trailing section with no heading. Declared here rather than on a module, because a group spans modules and no module can own one. Two groups may not share an id: every field of the second one is legal on its own, and the app still refuses to start.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "id",
+              "label"
+            ],
+            "properties": {
+              "id": {
+                "type": "string",
+                "minLength": 1,
+                "title": "Id",
+                "description": "What a module's navigation item names to join this group. Never shown to anyone, and no two groups may share one."
+              },
+              "label": {
+                "type": "string",
+                "title": "Heading",
+                "description": "The heading shown above this group's links. Leave it empty for a group that shows no heading at all — a way to place items somewhere other than the end without inventing a title for them."
+              },
+              "order": {
+                "type": "integer",
+                "title": "Position",
+                "description": "Where this group sits against its siblings, lowest first. Groups that share a position keep the order they are written in, so a list that is already in the right order needs no positions at all."
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/layout.manifest.test.ts

@@ -0,0 +1,205 @@
+import { readFileSync } from "node:fs";
+
+import { describe, expect, it } from "vitest";
+
+import { LAYOUT_CONTRACTS } from "./layoutContract";
+import {
+  BRAND_FIELDS,
+  NAV_GROUP_FIELDS,
+  NAV_GROUP_REQUIRED,
+  SHELL_STRUCTURED_KEYS,
+  SHELL_VALUES,
+  TOP_LEVEL_KEYS,
+} from "./layoutDeclaration";
+import { THEMES } from "./themes";
+
+// The published layout vocabulary against the module that enforces it.
+//
+// `layout.manifest.json` exists so that a tool editing an app's files can offer exactly the keys
+// and values THAT APP'S OWN pinned framework will honour. That inversion is the point: an unknown
+// key is refused when the router is composed, so a tool working from its own idea of the
+// vocabulary can hand an app a file its framework will not start on. Reading the vocabulary out
+// of the app's own node_modules removes the guess.
+//
+// Which makes every drift here a live defect rather than a tidiness problem, and both directions
+// fail differently:
+//
+//   * A key or value the resolver reads and the manifest omits is a choice no tool will ever
+//     offer — declarable, documented, and invisible to the audience the file was published for.
+//   * A key or value the manifest offers and the resolver does not read is worse: a tool writes
+//     it in good faith and the app refuses to start, naming a key the tool was told to use.
+//
+// The manifest is hand-written rather than generated, for the reason `theme.themes.test.ts` gives
+// about the theme union: generating it would need a TypeScript loader in a build step this package
+// does not have, and half its content — the titles and descriptions an operator reads — is not
+// derivable from the source at all. So the copy stays a copy, and the copy is checked.
+//
+// What "checked" covers, precisely, because an earlier version of this comment claimed more than
+// the assertions delivered: every key at all three levels, every enum, every declared type, every
+// emptiness floor, the required pair, the unknown-key refusals, and the export subpath. What it
+// does NOT cover is prose — a title or description is asserted present, never compared to
+// anything, because there is nothing to compare it to.
+
+interface ManifestProperty {
+  type?: string;
+  title?: string;
+  description?: string;
+  enum?: string[];
+  properties?: Record<string, ManifestProperty>;
+  items?: ManifestProperty;
+  required?: string[];
+  additionalProperties?: boolean;
+  minLength?: number;
+}
+
+const manifest: ManifestProperty = JSON.parse(
+  readFileSync(new URL("./layout.manifest.json", import.meta.url), "utf-8"),
+);
+
+const properties = manifest.properties ?? {};
+const shell = properties.shell?.properties ?? {};
+const group = shell.navGroups?.items?.properties ?? {};
+
+/** Every property in the document, by the path a refusal would name it with. */
+function everyProperty(): [string, ManifestProperty][] {
+  return [
+    ...Object.entries(properties).map(([key, value]): [string, ManifestProperty] => [key, value]),
+    ...Object.entries(shell).map(([key, value]): [string, ManifestProperty] => [
+      `shell.${key}`,
+      value,
+    ]),
+    ...Object.entries(group).map(([key, value]): [string, ManifestProperty] => [
+      `shell.navGroups.items.${key}`,
+      value,
+    ]),
+  ];
+}
+
+describe("the published layout vocabulary", () => {
+  it("reads the manifest it is asserting about", () => {
+    // Every assertion below compares against something parsed out of the file. A file that
+    // failed to parse into the expected shape would compare empty objects and report green,
+    // which is the one failure mode a parity test cannot afford.
+    expect(Object.keys(properties).length).toBeGreaterThan(2);
+    expect(Object.keys(shell).length).toBeGreaterThan(2);
+    expect(Object.keys(group).length).toBeGreaterThan(2);
+  });
+
+  it("offers exactly the keys the document admits", () => {
+    expect(Object.keys(properties).sort()).toEqual([...TOP_LEVEL_KEYS].sort());
+  });
+
+  it("offers exactly the keys the shell admits", () => {
+    const declared = [...Object.keys(SHELL_VALUES), ...SHELL_STRUCTURED_KEYS];
+    expect(Object.keys(shell).sort()).toEqual(declared.sort());
+  });
+
+  it("offers exactly the values each shell key accepts", () => {
+    for (const [key, values] of Object.entries(SHELL_VALUES)) {
+      expect(shell[key]?.enum, `shell.${key}`).toEqual([...values]);
+    }
+  });
+
+  it("offers every palette this release ships, and no other", () => {
+    // Including "system", which is a real thing to declare rather than the absence of one — an
+    // absent key leaves whatever was in force alone, this one pins the platform preference.
+    expect(properties.defaultTheme?.enum).toEqual([...THEMES]);
+  });
+
+  it("offers every layout contract this release knows, and no other", () => {
+    // A contract offered here that `buildAppRouter` cannot find is an app that refuses to
+    // start with "Unknown layout contract", pointing at a value a tool was told was legal.
+    expect(properties.contract?.enum?.slice().sort()).toEqual(Object.keys(LAYOUT_CONTRACTS).sort());
+  });
+
+  it("offers exactly the fields a navigation group carries", () => {
+    expect(Object.keys(group).sort()).toEqual([...NAV_GROUP_FIELDS].sort());
+    // Against the resolver's own list, not against a copy of it written here. Comparing a
+    // mirror to a second copy of the thing it mirrors proves nothing about either.
+    expect(shell.navGroups?.items?.required?.slice().sort()).toEqual(
+      [...NAV_GROUP_REQUIRED].sort(),
+    );
+  });
+
+  it("offers exactly the slots a brand declares", () => {
+    const brand = shell.brand?.properties ?? {};
+    expect(Object.keys(brand).sort()).toEqual([...BRAND_FIELDS].sort());
+    expect(shell.brand?.type).toBe("object");
+    expect(shell.brand?.additionalProperties).toBe(false);
+    // Both floored and neither required: an empty path is a mark that fails to load, while an
+    // absent one is the app saying it has no second file.
+    for (const slot of BRAND_FIELDS) {
+      expect(brand[slot]?.type, slot).toBe("string");
+      expect(brand[slot]?.minLength, slot).toBe(1);
+    }
+    expect(shell.brand?.required).toBeUndefined();
+  });
+
+  it("refuses an unknown key at every level it has one", () => {
+    // The manifest describes a document whose consumer refuses unknown keys at both levels and
+    // on a group entry. A manifest that said otherwise would tell a tool it may write anything.
+    expect(manifest.additionalProperties).toBe(false);
+    expect(properties.shell?.additionalProperties).toBe(false);
+    expect(shell.navGroups?.items?.additionalProperties).toBe(false);
+  });
+
+  it("gives every property a title and a description", () => {
+    // The half of the file no generator could produce, and the reason it is hand-written. A
+    // property with neither renders in a form as its own key and nothing else, which for
+    // `navPlacement` is a shrug and for `contract` is a choice that can turn a build red.
+    for (const [path, property] of everyProperty()) {
+      expect(property.title?.trim(), `${path}: title`).toBeTruthy();
+      expect(property.description?.trim(), `${path}: description`).toBeTruthy();
+    }
+  });
+
+  it("declares a type for every property, so a renderer never has to guess", () => {
+    for (const [path, property] of everyProperty()) {
+      expect(property.type, `${path}: type`).toBeTruthy();
+    }
+  });
+
+  it("declares the type the resolver actually refuses anything else for", () => {
+    // Truthiness was the whole of this check, and truthiness is not a type: with `navGroups`
+    // retyped to "object" and `order` to "string" every assertion in this file stayed green,
+    // while `resolveNavGroups` refuses a non-array and a non-integer by name. That is exactly
+    // the failure the header calls worse — a tool writes `"navGroups": {}` in good faith,
+    // reading a type the manifest offered, and the app will not compose.
+    expect(shell.navGroups?.type).toBe("array");
+    expect(shell.navGroups?.items?.type).toBe("object");
+    expect(group.order?.type).toBe("integer");
+    expect(group.id?.type).toBe("string");
+    expect(group.label?.type).toBe("string");
+    for (const key of Object.keys(SHELL_VALUES)) {
+      expect(shell[key]?.type, `shell.${key}`).toBe("string");
+    }
+  });
+
+  it("declares the emptiness floors the resolver refuses, and no others", () => {
+    // Each of these is a value the resolver rejects, so a manifest offering it without the
+    // floor tells a tool the empty string is legal. And `label` must NOT carry one: the empty
+    // label is how the document declares a group that renders no heading, and a floor there
+    // would tell a tool to refuse the one way of stating that.
+    expect(properties.contract?.minLength).toBe(1);
+    expect(properties.defaultTheme?.minLength).toBe(1);
+    expect(group.id?.minLength).toBe(1);
+    expect(group.label?.minLength).toBeUndefined();
+    expect(group.order?.minLength).toBeUndefined();
+  });
+
+  it("is reachable by the subpath a consumer imports it from", () => {
+    // The file only does its job from inside an app's node_modules, and the only thing that
+    // puts it there under a stable name is the package's own export map. A rename that moved
+    // the file would leave every gate above green while the published path 404s in the one
+    // place the file is read — and this package's own suite reads it by relative URL, so
+    // nothing else here would notice.
+    const pkg: { exports: Record<string, string> } = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf-8"),
+    );
+    const subpath = pkg.exports["./layout.manifest.json"];
+    expect(subpath).toBe("./src/layout.manifest.json");
+    expect(
+      readFileSync(new URL(`../${subpath!.slice(2)}`, import.meta.url), "utf-8").length,
+    ).toBeGreaterThan(0);
+  });
+});