@colixsystems/widget-sdk 0.84.0 → 0.85.1

package/README.md

@@ -18,12 +18,13 @@ The data layer lives in **four separate domain-client packages**, each instantia
 | Group | Hook (signature) | Returns | Reads / scope |
 | ----- | ---------------- | ------- | ------------- |
 | **CORE** | `useTheme()` | `{ colors, elevation, spacing, radii, typography, components }` | `ctx.workspace.theme` — no scope. `elevation` is the shared depth scale (`none / sm / md / lg / xl`) you spread into a style; `colors` includes the accent's quiet tiers (`primarySoft` / `onPrimarySoft` / `primaryStrong`). `components` is HOST-OWNED (the theme's per-component style tokens); the host has already folded it into your `props.style`, so read `useWidgetStyle()` and ignore this slice. |
+| **CORE** | `useWorkspaceCurrency()` | `{ currency, formatMoney }` | `ctx.workspace.currency` — no scope. The currency this workspace charges its app users in, resolved at RENDER time. Render every price as `formatMoney(minorUnits)` and never write a currency symbol or code into a widget: the owner can change it after the widget ships, and a baked label then contradicts the charge. |
 | **CORE** | `useWidgetStyle()` | `{ [styleField]: value }` | `ctx.props.style` — no scope. The author-set per-widget style values declared in `manifest.styleSchema`; apply each onto whatever element you choose. |
 | **CORE** | `useUser()` | `{ id, email, displayName, roles, groupIds }` | `ctx.user` (host-built context, **camelCase** — not a wire payload; `id` null when anonymous) — no scope |
 | **CORE** | `useNavigation()` | `{ goTo, goBack, push, replace, back, currentRoute }` | `ctx.navigation` — no scope (external URLs use the `Linking` primitive) |
 | **CORE** | `useRouteParams()` | `{ [paramKey]: value }` | `ctx.navigation.currentRoute.params` — no scope. The nav params the previous page passed via `goTo(pageId, params)`; the flat accessor for master→detail (read `recordId` on a detail page). Empty object when none. |
 | **CORE** | `usePageContext()` | `{ params, records }` | `ctx.pageContext` — no scope. The page's DECLARED parameters, resolved once by the host: `params` are coerced to their declared types, `records` holds the row already fetched for each `record` param (read it instead of fetching again). Both empty when the page declares none. |
-| **CORE** | `useWidgetEvent(name)` | `(payload?) => void` | `ctx.events.emit` — no scope |
+| **CORE** | `useWidgetEvent(name)` | `(payload?) => void` | `ctx.events.emit` — no scope. The hook IS the emitter: `const emitSlot = useWidgetEvent("slotChosen")`, then `emitSlot(payload)`. Never destructure the result — there is no `emit` member. |
 | **CORE** | `useWidgetInput(inputName)` | the published payload, or `undefined` | `ctx.inputs` — no scope. Reads a value ANOTHER widget on the same page published with `useWidgetEvent`. Declare the input in `manifest.inputs`; the page author wires it to one sibling's declared event. The channel retains the last payload, so a widget that mounts later still reads it. `undefined` while unwired or before the first publish — always render a sensible default. Page-scoped and ephemeral: use `useRouteParams()` for state that must survive navigation, the datastore for state that must persist. |
 | **CORE** | `useChildRenderer()` | `{ renderNode(node) }` | `ctx.renderer` — no scope (prefer the `WidgetTree` component) |
 | **CORE** | `useFill()` | `boolean` | `ctx.fill` — no scope. `true` when the host sized this widget to fill its page-grid tile's reserved height (containers + media fill by default; the author can override per tile). Media-style widgets switch to a `flex: 1` / `height: "100%"` layout; others ignore it. Defaults `false`. |
@@ -62,6 +63,14 @@ See the design reference for the full architecture: [`docs/architecture/widget-m
 
 `v0.77.0` — pre-publish. The package surface (types, function names, export paths) is the v1 contract; runtime behaviour for some hooks is stubbed (each hook documents what's wired and what isn't). It is **not yet published to npm**.
 
+### What's new in 0.85.1 (contract 1.60.1)
+
+**`useWidgetEvent(name)` returns the emitter FUNCTION — the declared contract said otherwise (sc-4753).** `CONTRACT.hooks`'s entry for the hook declared `returnShape: { emit }`, so every surface derived from it — chiefly the Widget Builder Agent's hooks table — told authors the hook resolves to an object. It never did: `useWidgetEvent("slotChosen")` hands back the callable you invoke directly (`emitSlot({ courtId })`), exactly as the typings and the Developer guide have always documented. A widget written against the declared shape destructured a function, got `undefined`, and threw the moment a user interacted — a cross-widget wire that rendered perfectly and only failed on click. The declaration is now a bare callable and the publish-time render harness models the same shape, so a wrong destructure is caught instead of waved through. `CONTRACT.version` → `1.60.1`. Documentation-only correction: no export, signature, or runtime behaviour changed — a widget already calling the result is unaffected.
+
+### What's new in 0.85.0 (contract 1.60.0)
+
+**A widget must never name a currency — `useWorkspaceCurrency()` resolves it at render time (sc-4686).** A workspace picks the currency it charges its app users in, and the owner usually sets that *after* the app is built (the normal order is prompt first, billing later). So anything a widget wrote down — a `"kr"` in JSX, a `€` in a `manifest.translations` string, a `currency` argument on `requestPayment` — kept displaying the old currency over a charge that had correctly followed the change: one price shown, another taken. Currency is workspace configuration that changes after authoring, exactly like `theme` and `locale`, so it now joins them on the host-resolved `ctx.workspace` slice. `useWorkspaceCurrency()` returns `{ currency, formatMoney }`; `formatMoney(45000)` renders `"450,00 kr"` or `"450,00 €"` from `CONTRACT.currencyFormats` — an explicit table, not `Intl.NumberFormat`, which does not agree between the exported Expo app and react-native-web. Omit `currency` on `requestPayment` and the platform applies the workspace's own, so it can never be wrong. Enforcement tightened to match: `payment-currency` now rejects **any** currency literal (one that matches today still lies tomorrow) and so needs no per-workspace option — it fires in a bare `appstudio-widget lint`, and `lintSource`'s `paymentCurrency` option is removed; a new `no-hardcoded-currency-label` warning catches a symbol or code beside a price in a charging widget. `CONTRACT.version` → `1.60.0`. Additive for a widget that already omits `currency`.
+
 ### What's new in 0.84.0 (contract 1.59.0)
 
 **A charge is denominated in the WORKSPACE's currency, and a widget that hardcodes a different one no longer publishes (sc-4649).** Every workspace picks the currency it charges its app users in, and `POST /payments/widget-charge` refuses any other code with `UNSUPPORTED_CURRENCY` — but nothing told a widget author which one that was. A widget priced in EUR for a workspace selling in SEK compiled, rendered, and looked finished, then failed every single checkout; the buyer read that as a generic "payment failed" and retried forever. Two changes: `currency` on `requestPayment` is best **omitted** (the platform applies the workspace's own, so it can never be wrong), and a literal that disagrees is now a publish-blocking `payment-currency` finding. Because the expected code is **per-workspace**, the SDK cannot know it: the rule fires only when the caller supplies `lintSource(source, { paymentCurrency })`, which the platform's publish gate does and a local `appstudio-widget lint` does not — it stays silent rather than guessing and flagging correct code. The rule is scoped to the argument of a `requestPayment(...)` call, so a `currency` field elsewhere (a datastore column, an `Intl.NumberFormat` option) is untouched. `CONTRACT.version` → `1.59.0`. Additive; a widget that omits `currency` or already matches its workspace is unaffected.

package/dist/contract.cjs

@@ -782,7 +782,16 @@ const HOOKS = [
   {
     name: "useWidgetEvent",
     signature: "useWidgetEvent(eventName)",
-    returnShape: { emit: "(payload?) => void" },
+    // sc-4753 — the hook IS the emitter, so its return is declared as a bare
+    // callable. Naming an `emit` member here made every derived surface tell
+    // authors to destructure a function, which yields undefined at run time.
+    returnShape: {
+      "(returns)":
+        "(payload?) => void  // the hook returns the emitter FUNCTION itself, " +
+        "not a wrapper object. Call it directly: " +
+        "const emitSlot = useWidgetEvent(\"slotChosen\"); " +
+        "emitSlot({ courtId }). Never destructure the result.",
+    },
     requiredContextSlice: ["events.emit"],
     scopes: null,
   },
@@ -810,6 +819,22 @@ const HOOKS = [
     requiredContextSlice: ["payments.requestPayment"],
     scopes: ["payments.charge:appUser"],
   },
+  // sc-4686 — the workspace's charge currency + the only sanctioned way to
+  // render money. A widget must NOT name a currency: the owner can change it
+  // after the widget was authored, so a baked symbol goes stale over a charge
+  // that followed the change.
+  {
+    name: "useWorkspaceCurrency",
+    signature: "useWorkspaceCurrency()",
+    returnShape: {
+      currency:
+        "string  // the ISO code this workspace charges its app users in, e.g. \"SEK\"",
+      formatMoney:
+        "(minorUnits) => string  // 45000 -> \"450,00 kr\"; renders identically on web and native. NEVER write a currency symbol or code yourself",
+    },
+    requiredContextSlice: ["workspace.currency"],
+    scopes: null,
+  },
   // sc-890 — send an in-app notification to one app user in the tenant.
   // IMPERATIVE: send() never fires on mount; the widget calls it from an
   // event handler. Reads ctx.notifications.send (the injected
@@ -1457,13 +1482,15 @@ const WIDGET_CONTEXT_SHAPE = {
   },
   workspace: {
     description:
-      "Workspace identity + resolved theme ({ id, slug, theme, locale }).",
+      "Workspace identity + resolved theme + charge currency ({ id, slug, theme, locale, currency }).",
     required: true,
     fields: {
       id: "string",
       slug: "string",
       theme: "ThemeTokens",
       locale: "string",
+      // sc-4686 — the ISO code this workspace charges its app users in.
+      currency: "string",
     },
   },
   navigation: {
@@ -2010,6 +2037,115 @@ const TRANSLATION_API_HOSTS = [
   "lingvanex.com",
 ];
 
+// sc-4686 — the currency a price renders in when the HOST does not supply the
+// workspace's own (a host predating the workspace.currency slice, or a caller
+// that forgot to wire it). A rendering fallback so a price is never blank or
+// "undefined" — NOT a statement about which currencies the server accepts,
+// which is per-workspace and operator-configured (sc-4649).
+const CHARGE_CURRENCY = "SEK";
+
+// sc-4686 — how each accepted currency is written, so a widget never has to.
+//
+// A widget must not name a currency: it is workspace configuration the owner
+// can change AFTER the widget was authored (see `chargeCurrency` on the
+// workspace context slice), so a baked "kr" or "€" goes stale the moment they
+// switch. Widgets render money through `useWorkspaceCurrency().formatMoney`,
+// which reads this table.
+//
+// Deliberately NOT `Intl.NumberFormat`: the exported Expo app and
+// react-native-web do not agree on its output (the same reason widgets format
+// dates with `date-fns` rather than `toLocaleDateString`), and this string ends
+// up on a price the buyer compares against the amount they are charged. An
+// explicit table renders byte-identically on both hosts.
+//
+// `symbol` is written `before` or `after` the amount; `space` inserts a
+// non-breaking gap between them. `decimals` is the minor-unit exponent, so it
+// is also how many minor units make one major unit.
+const CURRENCY_FORMATS = {
+  SEK: { symbol: "kr", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  NOK: { symbol: "kr", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  DKK: { symbol: "kr.", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  ISK: { symbol: "kr", position: "after", space: true, decimals: 0, decimalSeparator: ",", groupSeparator: "." },
+  EUR: { symbol: "€", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  GBP: { symbol: "£", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  USD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  CAD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  AUD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  NZD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  CHF: { symbol: "CHF", position: "before", space: true, decimals: 2, decimalSeparator: ".", groupSeparator: "'" },
+  PLN: { symbol: "zł", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  CZK: { symbol: "Kč", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  HUF: { symbol: "Ft", position: "after", space: true, decimals: 0, decimalSeparator: ",", groupSeparator: " " },
+  RON: { symbol: "lei", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  BGN: { symbol: "лв", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  JPY: { symbol: "¥", position: "before", space: false, decimals: 0, decimalSeparator: ".", groupSeparator: "," },
+  INR: { symbol: "₹", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  ILS: { symbol: "₪", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  ZAR: { symbol: "R", position: "before", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  MXN: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  BRL: { symbol: "R$", position: "before", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  SGD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  HKD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  AED: { symbol: "AED", position: "before", space: true, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  TRY: { symbol: "₺", position: "before", space: false, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  THB: { symbol: "฿", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  KRW: { symbol: "₩", position: "before", space: false, decimals: 0, decimalSeparator: ".", groupSeparator: "," },
+  CNY: { symbol: "¥", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+};
+
+// An unlisted currency still has to render something a buyer can read, so the
+// ISO code stands in for a symbol rather than the amount appearing bare.
+const CURRENCY_FORMAT_FALLBACK = Object.freeze({
+  position: "after",
+  space: true,
+  decimals: 2,
+  decimalSeparator: ".",
+  groupSeparator: ",",
+});
+
+// sc-4686 — the ISO code a workspace charges in, normalised. An empty value
+// means a host that predates the `workspace.currency` slice; falling back to the
+// platform default keeps a price rendering rather than printing "undefined" next
+// to an amount, which is the one place a blank is unacceptable.
+function normaliseCurrencyCode(value) {
+  const code = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return code || CHARGE_CURRENCY;
+}
+
+/**
+ * `formatMoneyIn("SEK", 45000)` → `"450,00 kr"`.
+ *
+ * Takes MINOR units — the same unit `requestPayment` charges in — so there is no
+ * conversion step for a widget to get wrong. Renders from `CURRENCY_FORMATS`
+ * rather than `Intl.NumberFormat`, which does not produce identical output in
+ * the exported Expo app and react-native-web; this string sits beside the amount
+ * the buyer is actually charged, so the two hosts must agree exactly.
+ *
+ * A non-finite amount renders as zero rather than "NaN": a price whose data has
+ * not loaded should read as an amount, never as a broken string in a checkout.
+ */
+function formatMoneyIn(currency, minorUnits) {
+  const code = normaliseCurrencyCode(currency);
+  const fmt = CURRENCY_FORMATS[code] || {
+    ...CURRENCY_FORMAT_FALLBACK,
+    symbol: code,
+  };
+  const amount = Number(minorUnits);
+  const safe = Number.isFinite(amount) ? Math.round(amount) : 0;
+  const negative = safe < 0;
+  const digits = String(Math.abs(safe)).padStart(fmt.decimals + 1, "0");
+  const whole = fmt.decimals > 0 ? digits.slice(0, -fmt.decimals) : digits;
+  const cents = fmt.decimals > 0 ? digits.slice(-fmt.decimals) : "";
+  const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, fmt.groupSeparator);
+  const body = cents ? `${grouped}${fmt.decimalSeparator}${cents}` : grouped;
+  const gap = fmt.space ? " " : "";
+  const withSymbol =
+    fmt.position === "before"
+      ? `${fmt.symbol}${gap}${body}`
+      : `${body}${gap}${fmt.symbol}`;
+  return negative ? `-${withSymbol}` : withSymbol;
+}
+
 function deepFreeze(value) {
   if (value === null || typeof value !== "object") return value;
   if (Object.isFrozen(value)) return value;
@@ -2524,7 +2660,13 @@ const CONTRACT = deepFreeze({
   //    `recipient_expr` shape and no recipient column can name them. The member
   //    list stays host-side — a script receives a count, never the ids — and
   //    `exclude_user_id` keeps an author off their own message.
-  version: "1.59.0",
+  // 1.60.1: fix (sc-4753) — `useWidgetEvent`'s declared `returnShape` claimed
+  //    the hook resolves to an object with an `emit` member. It returns the
+  //    emitter FUNCTION itself, exactly as hooks.js, index.d.ts and the
+  //    Developer guide have always said, so a widget written against the
+  //    declared shape destructured a function and threw on first interaction.
+  //    Declared as a bare callable now; no runtime behaviour changed.
+  version: "1.60.1",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -2546,6 +2688,9 @@ const CONTRACT = deepFreeze({
   allowedBareImports: ALLOWED_BARE_IMPORTS,
   hostApiUrlPatterns: HOST_API_URL_PATTERNS,
   payloadValueTypes: PAYLOAD_VALUE_TYPES,
+  chargeCurrency: CHARGE_CURRENCY,
+  currencyFormats: CURRENCY_FORMATS,
+  currencyFormatFallback: CURRENCY_FORMAT_FALLBACK,
   translationApiHosts: TRANSLATION_API_HOSTS,
 });
 
@@ -2721,6 +2866,8 @@ module.exports = {
   deriveAccentTints,
   gradientAngleToVector,
   normaliseComponentGradient,
+  formatMoneyIn,
+  normaliseCurrencyCode,
   widgetTranslationPrefix,
   widgetTranslationKey,
   sharedTranslationPrefix,

package/dist/contract.js

@@ -782,7 +782,16 @@ const HOOKS = [
   {
     name: "useWidgetEvent",
     signature: "useWidgetEvent(eventName)",
-    returnShape: { emit: "(payload?) => void" },
+    // sc-4753 — the hook IS the emitter, so its return is declared as a bare
+    // callable. Naming an `emit` member here made every derived surface tell
+    // authors to destructure a function, which yields undefined at run time.
+    returnShape: {
+      "(returns)":
+        "(payload?) => void  // the hook returns the emitter FUNCTION itself, " +
+        "not a wrapper object. Call it directly: " +
+        "const emitSlot = useWidgetEvent(\"slotChosen\"); " +
+        "emitSlot({ courtId }). Never destructure the result.",
+    },
     requiredContextSlice: ["events.emit"],
     scopes: null,
   },
@@ -810,6 +819,22 @@ const HOOKS = [
     requiredContextSlice: ["payments.requestPayment"],
     scopes: ["payments.charge:appUser"],
   },
+  // sc-4686 — the workspace's charge currency + the only sanctioned way to
+  // render money. A widget must NOT name a currency: the owner can change it
+  // after the widget was authored, so a baked symbol goes stale over a charge
+  // that followed the change.
+  {
+    name: "useWorkspaceCurrency",
+    signature: "useWorkspaceCurrency()",
+    returnShape: {
+      currency:
+        "string  // the ISO code this workspace charges its app users in, e.g. \"SEK\"",
+      formatMoney:
+        "(minorUnits) => string  // 45000 -> \"450,00 kr\"; renders identically on web and native. NEVER write a currency symbol or code yourself",
+    },
+    requiredContextSlice: ["workspace.currency"],
+    scopes: null,
+  },
   // sc-890 — send an in-app notification to one app user in the tenant.
   // IMPERATIVE: send() never fires on mount; the widget calls it from an
   // event handler. Reads ctx.notifications.send (the injected
@@ -1457,13 +1482,15 @@ const WIDGET_CONTEXT_SHAPE = {
   },
   workspace: {
     description:
-      "Workspace identity + resolved theme ({ id, slug, theme, locale }).",
+      "Workspace identity + resolved theme + charge currency ({ id, slug, theme, locale, currency }).",
     required: true,
     fields: {
       id: "string",
       slug: "string",
       theme: "ThemeTokens",
       locale: "string",
+      // sc-4686 — the ISO code this workspace charges its app users in.
+      currency: "string",
     },
   },
   navigation: {
@@ -2010,6 +2037,115 @@ const TRANSLATION_API_HOSTS = [
   "lingvanex.com",
 ];
 
+// sc-4686 — the currency a price renders in when the HOST does not supply the
+// workspace's own (a host predating the workspace.currency slice, or a caller
+// that forgot to wire it). A rendering fallback so a price is never blank or
+// "undefined" — NOT a statement about which currencies the server accepts,
+// which is per-workspace and operator-configured (sc-4649).
+const CHARGE_CURRENCY = "SEK";
+
+// sc-4686 — how each accepted currency is written, so a widget never has to.
+//
+// A widget must not name a currency: it is workspace configuration the owner
+// can change AFTER the widget was authored (see `chargeCurrency` on the
+// workspace context slice), so a baked "kr" or "€" goes stale the moment they
+// switch. Widgets render money through `useWorkspaceCurrency().formatMoney`,
+// which reads this table.
+//
+// Deliberately NOT `Intl.NumberFormat`: the exported Expo app and
+// react-native-web do not agree on its output (the same reason widgets format
+// dates with `date-fns` rather than `toLocaleDateString`), and this string ends
+// up on a price the buyer compares against the amount they are charged. An
+// explicit table renders byte-identically on both hosts.
+//
+// `symbol` is written `before` or `after` the amount; `space` inserts a
+// non-breaking gap between them. `decimals` is the minor-unit exponent, so it
+// is also how many minor units make one major unit.
+const CURRENCY_FORMATS = {
+  SEK: { symbol: "kr", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  NOK: { symbol: "kr", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  DKK: { symbol: "kr.", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  ISK: { symbol: "kr", position: "after", space: true, decimals: 0, decimalSeparator: ",", groupSeparator: "." },
+  EUR: { symbol: "€", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  GBP: { symbol: "£", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  USD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  CAD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  AUD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  NZD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  CHF: { symbol: "CHF", position: "before", space: true, decimals: 2, decimalSeparator: ".", groupSeparator: "'" },
+  PLN: { symbol: "zł", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  CZK: { symbol: "Kč", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  HUF: { symbol: "Ft", position: "after", space: true, decimals: 0, decimalSeparator: ",", groupSeparator: " " },
+  RON: { symbol: "lei", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  BGN: { symbol: "лв", position: "after", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  JPY: { symbol: "¥", position: "before", space: false, decimals: 0, decimalSeparator: ".", groupSeparator: "," },
+  INR: { symbol: "₹", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  ILS: { symbol: "₪", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  ZAR: { symbol: "R", position: "before", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: " " },
+  MXN: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  BRL: { symbol: "R$", position: "before", space: true, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  SGD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  HKD: { symbol: "$", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  AED: { symbol: "AED", position: "before", space: true, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  TRY: { symbol: "₺", position: "before", space: false, decimals: 2, decimalSeparator: ",", groupSeparator: "." },
+  THB: { symbol: "฿", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+  KRW: { symbol: "₩", position: "before", space: false, decimals: 0, decimalSeparator: ".", groupSeparator: "," },
+  CNY: { symbol: "¥", position: "before", space: false, decimals: 2, decimalSeparator: ".", groupSeparator: "," },
+};
+
+// An unlisted currency still has to render something a buyer can read, so the
+// ISO code stands in for a symbol rather than the amount appearing bare.
+const CURRENCY_FORMAT_FALLBACK = Object.freeze({
+  position: "after",
+  space: true,
+  decimals: 2,
+  decimalSeparator: ".",
+  groupSeparator: ",",
+});
+
+// sc-4686 — the ISO code a workspace charges in, normalised. An empty value
+// means a host that predates the `workspace.currency` slice; falling back to the
+// platform default keeps a price rendering rather than printing "undefined" next
+// to an amount, which is the one place a blank is unacceptable.
+function normaliseCurrencyCode(value) {
+  const code = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return code || CHARGE_CURRENCY;
+}
+
+/**
+ * `formatMoneyIn("SEK", 45000)` → `"450,00 kr"`.
+ *
+ * Takes MINOR units — the same unit `requestPayment` charges in — so there is no
+ * conversion step for a widget to get wrong. Renders from `CURRENCY_FORMATS`
+ * rather than `Intl.NumberFormat`, which does not produce identical output in
+ * the exported Expo app and react-native-web; this string sits beside the amount
+ * the buyer is actually charged, so the two hosts must agree exactly.
+ *
+ * A non-finite amount renders as zero rather than "NaN": a price whose data has
+ * not loaded should read as an amount, never as a broken string in a checkout.
+ */
+function formatMoneyIn(currency, minorUnits) {
+  const code = normaliseCurrencyCode(currency);
+  const fmt = CURRENCY_FORMATS[code] || {
+    ...CURRENCY_FORMAT_FALLBACK,
+    symbol: code,
+  };
+  const amount = Number(minorUnits);
+  const safe = Number.isFinite(amount) ? Math.round(amount) : 0;
+  const negative = safe < 0;
+  const digits = String(Math.abs(safe)).padStart(fmt.decimals + 1, "0");
+  const whole = fmt.decimals > 0 ? digits.slice(0, -fmt.decimals) : digits;
+  const cents = fmt.decimals > 0 ? digits.slice(-fmt.decimals) : "";
+  const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, fmt.groupSeparator);
+  const body = cents ? `${grouped}${fmt.decimalSeparator}${cents}` : grouped;
+  const gap = fmt.space ? " " : "";
+  const withSymbol =
+    fmt.position === "before"
+      ? `${fmt.symbol}${gap}${body}`
+      : `${body}${gap}${fmt.symbol}`;
+  return negative ? `-${withSymbol}` : withSymbol;
+}
+
 function deepFreeze(value) {
   if (value === null || typeof value !== "object") return value;
   if (Object.isFrozen(value)) return value;
@@ -2524,7 +2660,13 @@ const CONTRACT = deepFreeze({
   //    `recipient_expr` shape and no recipient column can name them. The member
   //    list stays host-side — a script receives a count, never the ids — and
   //    `exclude_user_id` keeps an author off their own message.
-  version: "1.59.0",
+  // 1.60.1: fix (sc-4753) — `useWidgetEvent`'s declared `returnShape` claimed
+  //    the hook resolves to an object with an `emit` member. It returns the
+  //    emitter FUNCTION itself, exactly as hooks.js, index.d.ts and the
+  //    Developer guide have always said, so a widget written against the
+  //    declared shape destructured a function and threw on first interaction.
+  //    Declared as a bare callable now; no runtime behaviour changed.
+  version: "1.60.1",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -2546,6 +2688,9 @@ const CONTRACT = deepFreeze({
   allowedBareImports: ALLOWED_BARE_IMPORTS,
   hostApiUrlPatterns: HOST_API_URL_PATTERNS,
   payloadValueTypes: PAYLOAD_VALUE_TYPES,
+  chargeCurrency: CHARGE_CURRENCY,
+  currencyFormats: CURRENCY_FORMATS,
+  currencyFormatFallback: CURRENCY_FORMAT_FALLBACK,
   translationApiHosts: TRANSLATION_API_HOSTS,
 });
 
@@ -2721,6 +2866,8 @@ export {
   deriveAccentTints,
   gradientAngleToVector,
   normaliseComponentGradient,
+  formatMoneyIn,
+  normaliseCurrencyCode,
   widgetTranslationPrefix,
   widgetTranslationKey,
   sharedTranslationPrefix,

package/dist/hooks.js

@@ -33,10 +33,15 @@ import React, {
 // `sharedTranslationKey` builds the tenant-wide predefined key
 // (`shared.<key>`); `isSharedTranslationKey` tells the hook whether a bare key
 // is one of the predefined shared keys and so should try the shared namespace.
+// sc-4686 — `formatMoneyIn` lives beside the currency table it reads, for the
+// same single-source reason: the host, the compiler-parity tests and this hook
+// must render a price identically.
 import {
   widgetTranslationKey,
   sharedTranslationKey,
   isSharedTranslationKey,
+  formatMoneyIn,
+  normaliseCurrencyCode,
 } from "./contract.js";
 
 /** @internal — host-injected context value of shape WidgetContext (see index.d.ts). */
@@ -129,6 +134,34 @@ function readInput(inputs, inputName) {
     : undefined;
 }
 
+/**
+ * sc-4686 — the workspace's charge currency, and the only sanctioned way for a
+ * widget to render money.
+ *
+ * A widget must never name a currency. The owner picks what the workspace
+ * charges its app users in and can change it long AFTER the widget was authored,
+ * so a hardcoded "kr" or "€" starts lying about a charge that correctly followed
+ * the change. Reading it from the host means every existing widget survives a
+ * switch with no regeneration — the same reason `useTheme()` and `useI18n()`
+ * resolve the other two pieces of workspace configuration at render time.
+ *
+ * `formatMoney` takes MINOR units, the same unit `requestPayment` charges in.
+ *
+ * @returns {{ currency: string, formatMoney: (minorUnits: number) => string }}
+ */
+export function useWorkspaceCurrency() {
+  const ctx = useWidgetContextOrThrow("useWorkspaceCurrency");
+  const currency = ctx.workspace && ctx.workspace.currency;
+  // React.useMemo rather than a bare import — see the import block above.
+  return React.useMemo(
+    () => ({
+      currency: normaliseCurrencyCode(currency),
+      formatMoney: (minorUnits) => formatMoneyIn(currency, minorUnits),
+    }),
+    [currency],
+  );
+}
+
 /**
  * Returns the host-provided theme tokens. The host guarantees every field
  * documented in CONTRACT.themeTokens is present (defaults merged with

package/dist/index.d.ts

@@ -846,6 +846,19 @@ export interface SendNotificationApi {
  */
 export function useSendNotification(): SendNotificationApi;
 
+export interface WorkspaceCurrency {
+  /** The ISO code this workspace charges its app users in. */
+  currency: string;
+  /** MINOR units in, a display string out: 45000 -> "450,00 kr". */
+  formatMoney: (minorUnits: number) => string;
+}
+/**
+ * sc-4686 — the workspace charge currency + the only sanctioned way to render
+ * money. Never write a currency symbol or code into a widget: the owner can
+ * change it after the widget ships.
+ */
+export function useWorkspaceCurrency(): WorkspaceCurrency;
+
 export function useTheme(): ThemeTokens;
 
 /**
@@ -1768,12 +1781,6 @@ export interface LintFinding {
 }
 export interface LintOptions {
   manifest?: { requestedScopes?: string[]; supportedPlatforms?: string[] };
-  /**
-   * sc-4649 — the currency the target workspace charges its app users in. A
-   * per-workspace value the SDK cannot know, so the `payment-currency` rule
-   * stays silent unless the caller (the backend publish gate) supplies it.
-   */
-  paymentCurrency?: string;
 }
 export function lintSource(
   source: string,
@@ -1849,6 +1856,10 @@ export interface AiWidgetContract {
   readonly bundleExportContract: ReadonlyArray<ContractBundleShape>;
   readonly bannedApis: ReadonlyArray<ContractBannedApi>;
   readonly allowedBareImports: ReadonlyArray<string>;
+  /** sc-4686 — the render-time fallback currency when the host supplies none. */
+  readonly chargeCurrency: string;
+  /** sc-4686 — how each currency is written; read by `formatMoney`, never Intl. */
+  readonly currencyFormats: Readonly<Record<string, Readonly<{ symbol: string; position: "before" | "after"; space: boolean; decimals: number; decimalSeparator: string; groupSeparator: string }>>>;
 }
 
 export const CONTRACT: AiWidgetContract;

package/dist/index.js

@@ -38,6 +38,7 @@ export {
   useWidgetEvent,
   useWidgetInput,
   usePayments,
+  useWorkspaceCurrency,
   useSendNotification,
   useTheme,
   useWidgetStyle,

package/dist/index.native.js

@@ -38,6 +38,7 @@ export {
   useWidgetEvent,
   useWidgetInput,
   usePayments,
+  useWorkspaceCurrency,
   useSendNotification,
   useTheme,
   useWidgetStyle,

package/dist/linter.cjs

@@ -728,17 +728,15 @@ function _jsxOpenTagEnd(source, from) {
   return source.length;
 }
 
-// sc-4649 — see linter.js for the rationale comment. The two files must stay
-// in lockstep (the contract test asserts behaviour-equivalence).
+// sc-4649 / sc-4686 — see linter.js for the rationale comments. The two
+// files must stay in lockstep (a test asserts behaviour-equivalence).
 const REQUEST_PAYMENT_CALL = "requestPayment(";
 // A generous window: the options object is usually inline, occasionally spread
 // over a few lines. Bounded so an unbalanced source can't scan to EOF.
 const REQUEST_PAYMENT_WINDOW = 400;
 const CURRENCY_LITERAL_RE = /currency\s*:\s*(['"`])\s*([A-Za-z]{2,8})\s*\1/;
 
-function _paymentCurrencyRules(source, paymentCurrency) {
-  const expected = String(paymentCurrency || "").trim().toUpperCase();
-  if (!expected) return [];
+function _paymentCurrencyRules(source) {
   const findings = [];
   // Comments blanked, strings kept: the currency code IS a string literal.
   const code = _stripNonCode(source, { keepStrings: true });
@@ -752,18 +750,16 @@ function _paymentCurrencyRules(source, paymentCurrency) {
       code.slice(at, at + REQUEST_PAYMENT_WINDOW),
     );
     if (!match) continue;
-    const found = match[2].toUpperCase();
-    if (found === expected) continue;
     // Line of the currency literal itself, not of the call.
     const line = code.slice(0, at + match.index).split(/\r?\n/).length;
     findings.push({
       rule: "payment-currency",
       severity: "error",
       label:
-        `requestPayment charges in "${found}" but this workspace sells in ` +
-        `${expected}, and the server refuses any other currency, so the ` +
-        `checkout can never complete. Omit currency (the platform applies ` +
-        `${expected}) or pass exactly "${expected}".`,
+        `requestPayment hardcodes currency "${match[2].toUpperCase()}". Each ` +
+        `workspace charges in its OWN currency and can change it after this ` +
+        `widget ships, so OMIT currency — the platform applies the ` +
+        `workspace's — and show prices with useWorkspaceCurrency().formatMoney.`,
       line,
       snippet: (sourceLines[line - 1] || "").trim().slice(0, 200),
     });
@@ -771,6 +767,56 @@ function _paymentCurrencyRules(source, paymentCurrency) {
   return findings;
 }
 
+// sc-4686 — no-hardcoded-currency-label.
+//
+// The charge is safe once `currency` is omitted, but the DISPLAY is not: a "kr"
+// in JSX or a "€" in a translation string keeps showing the old currency after
+// the owner switches, so the widget tells the buyer one currency and charges
+// another. `formatMoney` renders the symbol from the workspace's currency.
+//
+// A `warning`, not an error: this is a text heuristic over string data, and a
+// legitimate non-price use exists (a currency-converter widget's own labels).
+// It drives an AI repair turn without hard-failing a human submission.
+//
+// Only in a widget that CHARGES — a widget with no `requestPayment` is not
+// displaying a price the platform is about to take money for. And only where the
+// symbol sits on a digit or a template hole, so prose can't trip it.
+const CURRENCY_LABEL_RES = [
+  // `${` is a template hole, `{` a JSX expression — a price is written both ways.
+  /[€£¥₹₺₪]\s*(?:\d|\$?\{)/,
+  /(?:\d|\})\s*(?:kr|kr\.|zł|Kč|Ft|lei|лв)\b/,
+  /\b(?:SEK|NOK|DKK|EUR|GBP|USD|CHF|PLN|CZK|HUF|JPY|INR)\b\s*(?:\d|\$\{)/,
+  /(?:\d|\})\s*\b(?:SEK|NOK|DKK|EUR|GBP|USD|CHF|PLN|CZK|HUF|JPY|INR)\b/,
+];
+
+function _hardcodedCurrencyLabelRules(source) {
+  const code = _stripNonCode(source, { keepStrings: true });
+  if (!code.includes(REQUEST_PAYMENT_CALL)) return [];
+  const findings = [];
+  const lines = code.split(/\r?\n/);
+  const sourceLines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    // The requestPayment call's own `currency:` literal is the other rule's
+    // finding — don't report the same line twice.
+    if (CURRENCY_LITERAL_RE.test(lines[i])) continue;
+    if (!CURRENCY_LABEL_RES.some((re) => re.test(lines[i]))) continue;
+    findings.push({
+      rule: "no-hardcoded-currency-label",
+      severity: "warning",
+      label:
+        `this charging widget writes a currency next to a price. The owner can ` +
+        `change the workspace's currency after it ships, leaving the label ` +
+        `wrong over a correct charge — render money with ` +
+        `useWorkspaceCurrency().formatMoney(amountInMinorUnits) instead.`,
+      line: i + 1,
+      snippet: (sourceLines[i] || "").trim().slice(0, 200),
+    });
+    // One per line is enough; a price line often matches twice.
+  }
+  return findings;
+}
+
+
 // sc-4650 — soft warning: a widget that charges must tell a failure worth
 // retrying from a refusal only the workspace owner can lift. Collapsing every
 // rejection into one "please try again" is what sent payers round an
@@ -894,9 +940,8 @@ function lintSource(source, options) {
   findings.push(..._reactInScopeRules(source));
   findings.push(..._imagePercentHeightRules(source));
   // sc-4650 — soft warning: every payment refusal reported as "try again".
-  findings.push(
-    ..._paymentCurrencyRules(source, options && options.paymentCurrency),
-  );
+  findings.push(..._paymentCurrencyRules(source));
+  findings.push(..._hardcodedCurrencyLabelRules(source));
   findings.push(..._paymentErrorHandlingRules(source));
   findings.push(
     ..._scopeRules(source, options && options.manifest).map((f) => ({

package/dist/linter.js

@@ -846,33 +846,29 @@ function _jsxOpenTagEnd(source, from) {
   return source.length;
 }
 
-// sc-4649 — payment-currency.
+// sc-4649 / sc-4686 — payment-currency.
 //
-// Each workspace charges its app users in ONE currency of its own choosing
-// (`Tenant.app_user_price_currency`), and the server refuses a charge in any
-// other with `UNSUPPORTED_CURRENCY`. A widget that hardcodes a different code
-// compiles, renders, and looks finished, but every checkout it runs dies on a
-// 400 — so this is an `error`, not a warning like `payment-error-not-branched`:
-// a literal mismatch is unambiguous and there is no correct code for an opt-out
-// directive to rescue.
+// A widget must not name a currency AT ALL. Each workspace charges its app users
+// in one currency of its own choosing, the owner can change it long after the
+// widget was authored, and the server refuses a charge in anything else — so
+// omitting `currency` is the ONLY always-correct call: the platform applies the
+// workspace's own, and an existing widget follows a switch with no rebuild.
 //
-// The expected currency is a PER-WORKSPACE value the SDK cannot know, so this
-// rule only fires when the caller supplies `options.paymentCurrency` — the
-// backend publish gate does, a bare `appstudio-widget lint` does not. There is
-// deliberately no default: guessing one would flag a correct widget.
+// That makes this rule workspace-INDEPENDENT (it needs no expected value passed
+// in, unlike its first sc-4649 form) and therefore it also fires in a bare
+// `appstudio-widget lint`, before a third-party developer ever uploads.
 //
-// Scoped to the argument of a `requestPayment(...)` call. A `currency` field
-// elsewhere (a datastore column, an `Intl.NumberFormat` option) is the widget's
-// own display concern and is not judged here.
+// `error`, not a warning like `payment-error-not-branched`: a literal here either
+// disagrees with the workspace and kills every checkout, or agrees today and
+// silently starts lying the moment the owner switches. Neither is code worth an
+// opt-out directive.
 const REQUEST_PAYMENT_CALL = "requestPayment(";
 // A generous window: the options object is usually inline, occasionally spread
 // over a few lines. Bounded so an unbalanced source can't scan to EOF.
 const REQUEST_PAYMENT_WINDOW = 400;
 const CURRENCY_LITERAL_RE = /currency\s*:\s*(['"`])\s*([A-Za-z]{2,8})\s*\1/;
 
-function _paymentCurrencyRules(source, paymentCurrency) {
-  const expected = String(paymentCurrency || "").trim().toUpperCase();
-  if (!expected) return [];
+function _paymentCurrencyRules(source) {
   const findings = [];
   // Comments blanked, strings kept: the currency code IS a string literal.
   const code = _stripNonCode(source, { keepStrings: true });
@@ -886,18 +882,16 @@ function _paymentCurrencyRules(source, paymentCurrency) {
       code.slice(at, at + REQUEST_PAYMENT_WINDOW),
     );
     if (!match) continue;
-    const found = match[2].toUpperCase();
-    if (found === expected) continue;
     // Line of the currency literal itself, not of the call.
     const line = code.slice(0, at + match.index).split(/\r?\n/).length;
     findings.push({
       rule: "payment-currency",
       severity: "error",
       label:
-        `requestPayment charges in "${found}" but this workspace sells in ` +
-        `${expected}, and the server refuses any other currency, so the ` +
-        `checkout can never complete. Omit currency (the platform applies ` +
-        `${expected}) or pass exactly "${expected}".`,
+        `requestPayment hardcodes currency "${match[2].toUpperCase()}". Each ` +
+        `workspace charges in its OWN currency and can change it after this ` +
+        `widget ships, so OMIT currency — the platform applies the ` +
+        `workspace's — and show prices with useWorkspaceCurrency().formatMoney.`,
       line,
       snippet: (sourceLines[line - 1] || "").trim().slice(0, 200),
     });
@@ -905,6 +899,56 @@ function _paymentCurrencyRules(source, paymentCurrency) {
   return findings;
 }
 
+// sc-4686 — no-hardcoded-currency-label.
+//
+// The charge is safe once `currency` is omitted, but the DISPLAY is not: a "kr"
+// in JSX or a "€" in a translation string keeps showing the old currency after
+// the owner switches, so the widget tells the buyer one currency and charges
+// another. `formatMoney` renders the symbol from the workspace's currency.
+//
+// A `warning`, not an error: this is a text heuristic over string data, and a
+// legitimate non-price use exists (a currency-converter widget's own labels).
+// It drives an AI repair turn without hard-failing a human submission.
+//
+// Only in a widget that CHARGES — a widget with no `requestPayment` is not
+// displaying a price the platform is about to take money for. And only where the
+// symbol sits on a digit or a template hole, so prose can't trip it.
+const CURRENCY_LABEL_RES = [
+  // `${` is a template hole, `{` a JSX expression — a price is written both ways.
+  /[€£¥₹₺₪]\s*(?:\d|\$?\{)/,
+  /(?:\d|\})\s*(?:kr|kr\.|zł|Kč|Ft|lei|лв)\b/,
+  /\b(?:SEK|NOK|DKK|EUR|GBP|USD|CHF|PLN|CZK|HUF|JPY|INR)\b\s*(?:\d|\$\{)/,
+  /(?:\d|\})\s*\b(?:SEK|NOK|DKK|EUR|GBP|USD|CHF|PLN|CZK|HUF|JPY|INR)\b/,
+];
+
+function _hardcodedCurrencyLabelRules(source) {
+  const code = _stripNonCode(source, { keepStrings: true });
+  if (!code.includes(REQUEST_PAYMENT_CALL)) return [];
+  const findings = [];
+  const lines = code.split(/\r?\n/);
+  const sourceLines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    // The requestPayment call's own `currency:` literal is the other rule's
+    // finding — don't report the same line twice.
+    if (CURRENCY_LITERAL_RE.test(lines[i])) continue;
+    if (!CURRENCY_LABEL_RES.some((re) => re.test(lines[i]))) continue;
+    findings.push({
+      rule: "no-hardcoded-currency-label",
+      severity: "warning",
+      label:
+        `this charging widget writes a currency next to a price. The owner can ` +
+        `change the workspace's currency after it ships, leaving the label ` +
+        `wrong over a correct charge — render money with ` +
+        `useWorkspaceCurrency().formatMoney(amountInMinorUnits) instead.`,
+      line: i + 1,
+      snippet: (sourceLines[i] || "").trim().slice(0, 200),
+    });
+    // One per line is enough; a price line often matches twice.
+  }
+  return findings;
+}
+
+
 // sc-4650 — soft warning: a widget that charges must tell a failure worth
 // retrying from a refusal only the workspace owner can lift. Collapsing every
 // rejection into one "please try again" is what sent payers round an
@@ -1040,9 +1084,8 @@ export function lintSource(source, options) {
   // sc-3493 — soft warning: percentage height on an <Image> collapses to 0.
   findings.push(..._imagePercentHeightRules(source));
   // sc-4650 — soft warning: every payment refusal reported as "try again".
-  findings.push(
-    ..._paymentCurrencyRules(source, options && options.paymentCurrency),
-  );
+  findings.push(..._paymentCurrencyRules(source));
+  findings.push(..._hardcodedCurrencyLabelRules(source));
   findings.push(..._paymentErrorHandlingRules(source));
   // REQ-USERMGMT / REQ-ACL-SYS M3 — scope-aware rules. Run after the
   // line-by-line scan so banned-identifier findings stay first in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colixsystems/widget-sdk",
-  "version": "0.84.0",
+  "version": "0.85.1",
   "description": "Common widget interface for AppStudio. Implements WidgetManifest, WidgetContext, property schema, and helper hooks.",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,7 +48,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.js",
-    "test": "node --test src/__tests__/contract.test.js src/__tests__/hooks-users.test.js src/__tests__/hooks-groups.test.js src/__tests__/hooks-schema.test.js src/__tests__/hooks-assets-by-tag.test.js src/__tests__/hooks-filestore-upload.test.js src/__tests__/hooks-filestore-file.test.js src/__tests__/hooks-mutation.test.js src/__tests__/hooks-payments.test.js src/__tests__/hooks-record-permissions.test.js src/__tests__/hooks-geolocation.test.js src/__tests__/hooks-section-empty.test.js src/__tests__/hooks-identification.test.js src/__tests__/hooks-subscription.test.js src/__tests__/hooks-volatile-query-key.test.js src/__tests__/linter-users-scope.test.js src/__tests__/linter-comments.test.js src/__tests__/linter-translation-api.test.js src/__tests__/linter-image-height.test.js src/__tests__/linter-payment-error.test.js src/__tests__/linter-platform.test.js src/__tests__/linter-react-import.test.js src/__tests__/lucide-icon-names.test.js src/__tests__/lucideIconName.test.js src/__tests__/manifest-actions.test.js src/__tests__/widget-translations.test.js src/__tests__/hooks-translate.test.js src/__tests__/devserver.test.js src/__tests__/host-externals.test.js src/__tests__/datetimepicker.test.js src/__tests__/property-schema-resolve.test.js src/__tests__/theme-components-parity.test.js src/__tests__/theme-depth-tokens.test.js"
+    "test": "node --test src/__tests__/contract.test.js src/__tests__/hooks-users.test.js src/__tests__/hooks-groups.test.js src/__tests__/hooks-schema.test.js src/__tests__/hooks-assets-by-tag.test.js src/__tests__/hooks-filestore-upload.test.js src/__tests__/hooks-filestore-file.test.js src/__tests__/hooks-mutation.test.js src/__tests__/hooks-payments.test.js src/__tests__/hooks-record-permissions.test.js src/__tests__/hooks-geolocation.test.js src/__tests__/hooks-section-empty.test.js src/__tests__/hooks-widget-event.test.js src/__tests__/hooks-widget-input.test.js src/__tests__/hooks-identification.test.js src/__tests__/hooks-subscription.test.js src/__tests__/hooks-volatile-query-key.test.js src/__tests__/linter-users-scope.test.js src/__tests__/linter-comments.test.js src/__tests__/linter-translation-api.test.js src/__tests__/linter-image-height.test.js src/__tests__/linter-payment-error.test.js src/__tests__/linter-platform.test.js src/__tests__/linter-react-import.test.js src/__tests__/lucide-icon-names.test.js src/__tests__/lucideIconName.test.js src/__tests__/manifest-actions.test.js src/__tests__/widget-translations.test.js src/__tests__/hooks-translate.test.js src/__tests__/devserver.test.js src/__tests__/host-externals.test.js src/__tests__/datetimepicker.test.js src/__tests__/property-schema-resolve.test.js src/__tests__/theme-components-parity.test.js src/__tests__/theme-depth-tokens.test.js"
   },
   "engines": {
     "node": ">=18"