@colixsystems/widget-sdk 0.102.0 → 0.103.0

package/README.md

@@ -21,7 +21,7 @@ The data layer lives in **four separate domain-client packages**, each instantia
 | **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, openLink }` | `ctx.navigation` — no scope (`openLink` for a link of unknown shape; a known external URL can also use the `Linking` primitive) |
+| **CORE** | `useNavigation()` | `{ goTo, goBack, push, replace, back, currentRoute, openLink }` | `ctx.navigation` — no scope. `goTo(pageIdOrSlug, params?)` accepts a page UUID (a `pageRef` prop) **or its slug** (a row's page-key field) — both hosts resolve either (`openLink` for a link of unknown shape; a known external URL can also 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** | `useWidgetRoute(initial)` | `[state, setState]` | `ctx.widgetRoute` — no scope. Where YOUR WIDGET is, persisted by the host so it survives a reload and travels in a shared link (the `w_<instanceId>` query key on web, the screen's route params natively): the folder a browser has opened, a wizard step, a selected tab, a list's sort and search. `useState` semantics over an object — writes MERGE, `null` clears a key back to its `initial`, and `initial` is read once. Values are scalars or flat arrays of scalars, size- and length-capped; anything else is not stored. NOT history (Back still leaves the page, on both platforms). Degrades to component state on the Studio canvas. |
@@ -68,7 +68,15 @@ See the design reference for the full architecture: [`docs/architecture/widget-m
 
 ## Status
 
-`v0.95.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**.
+`v0.103.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.103.0 (contract 1.78.0)
+
+**An app-wide style value may have SHAPE — `widgetStyles` is no longer scalars-only.** Your `styleSchema` is offered in two places: the widget editor (per placed instance) and Theme Settings (app-wide, under your widget's own name). A field holding a structured value — an overlay object, a list of ids — persisted in the first and was silently dropped by the second, so the same edit behaved two ways depending on where the author made it.
+
+`normaliseWidgetStyles` now carries objects and arrays, bounded by `CONTRACT.themeWidgetStyles`: `maxValueDepth` (3), `maxValueEntries` (24 per level), `maxValueBytes` (512 per field), and a new `maxBytes` (64000) over the whole map — a ceiling the per-scalar limits never stated, so the worst-case payload of that unauthenticated cold-start read is now *smaller* than before. `__proto__`-style keys are refused at every level.
+
+Host-integration surface only — nothing a widget imports changed, and your widget still reads `props.style` without learning which layer supplied a value. `CONTRACT.version` → `1.78.0`. Additive: every value accepted before is accepted now.
 
 ### What's new in 0.95.0 (contract 1.68.0)
 

package/dist/contract.cjs

@@ -158,6 +158,15 @@ const THEME_WIDGET_STYLES = Object.freeze({
   maxWidgets: 200,
   // Matches the styleSchema field cap the widget agent is held to.
   maxFieldsPerWidget: 12,
+  // sc-5646: a styleSchema field may hold a STRUCTURED value (a container's
+  // overlay, a list of ids), so the ceiling is stated in bytes rather than
+  // assumed to be one short scalar.
+  maxValueBytes: 512,
+  // The whole map, because it rides that unauthenticated cold-start read.
+  maxBytes: 64000,
+  // Nesting/width a structured value may reach before it is dropped.
+  maxValueDepth: 3,
+  maxValueEntries: 24,
 });
 // REQ-NAV-STRUCTURE: the SHAPE an app's navigation takes. One catalogue, four
 // consumers -- the Studio's Navigation page, Mason's set_theme coercion, the web
@@ -655,11 +664,12 @@ const HOOKS = [
     name: "useNavigation",
     signature: "useNavigation()",
     returnShape: {
-      goTo: "(pageId: string, params?: object) => void",
+      goTo:
+        "(pageIdOrSlug: string, params?: object) => void — a page's UUID (a pageRef prop) OR its SLUG (e.g. a row's page-key field); both hosts resolve either. There is NO page-name lookup: a slug is the only data-carried navigation key.",
       openLink: "(link: string) => boolean",
       goBack: "() => void",
-      push: "(pageId: string, params?: object) => void",
-      replace: "(pageId: string, params?: object) => void",
+      push: "(pageIdOrSlug: string, params?: object) => void",
+      replace: "(pageIdOrSlug: string, params?: object) => void",
       back: "() => void",
       currentRoute: "{ pageId: string, params: object }",
     },
@@ -3259,7 +3269,24 @@ const CONTRACT = deepFreeze({
   //    are compressed to WebP by default; `compress: false` stores the file
   //    byte-for-byte. Existing callers are unaffected — the field is only sent
   //    when the opt-out is chosen.
-  version: "1.76.0",
+  // 1.77.0: documentation (sc-5713) — `goTo`/`push`/`replace` document that
+  //    they accept a page SLUG as well as a page UUID. Both hosts have always
+  //    resolved either (the web route reads id-or-slug; the export's
+  //    PAGE_ROUTES maps both to the screen name), but the contract said
+  //    `pageId` only, so data-driven widgets — whose rows carry slugs —
+  //    invented params patterns that navigate nowhere. No code changed shape.
+  // 1.78.0: additive (sc-5646) — `widgetStyles` carries every value shape a
+  //    `styleSchema` field can produce, not just scalars and gradients. The
+  //    Studio offers the SAME field in the widget editor and in Theme
+  //    Settings, so a structured value (a container-style overlay, a list of
+  //    ids) that persisted per instance but was dropped app-wide made one
+  //    edit behave two ways. Objects and arrays are now carried, bounded by
+  //    `themeWidgetStyles.maxValueDepth` / `maxValueEntries` /
+  //    `maxValueBytes`, with `maxBytes` capping the whole map — a ceiling the
+  //    per-scalar limits never stated, so the worst-case unauthenticated
+  //    payload is SMALLER than before. `__proto__`-style keys are refused at
+  //    every level. Additive: every value accepted before is accepted now.
+  version: "1.78.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,

package/dist/contract.js

@@ -158,6 +158,15 @@ const THEME_WIDGET_STYLES = Object.freeze({
   maxWidgets: 200,
   // Matches the styleSchema field cap the widget agent is held to.
   maxFieldsPerWidget: 12,
+  // sc-5646: a styleSchema field may hold a STRUCTURED value (a container's
+  // overlay, a list of ids), so the ceiling is stated in bytes rather than
+  // assumed to be one short scalar.
+  maxValueBytes: 512,
+  // The whole map, because it rides that unauthenticated cold-start read.
+  maxBytes: 64000,
+  // Nesting/width a structured value may reach before it is dropped.
+  maxValueDepth: 3,
+  maxValueEntries: 24,
 });
 // REQ-NAV-STRUCTURE: the SHAPE an app's navigation takes. One catalogue, four
 // consumers -- the Studio's Navigation page, Mason's set_theme coercion, the web
@@ -655,11 +664,12 @@ const HOOKS = [
     name: "useNavigation",
     signature: "useNavigation()",
     returnShape: {
-      goTo: "(pageId: string, params?: object) => void",
+      goTo:
+        "(pageIdOrSlug: string, params?: object) => void — a page's UUID (a pageRef prop) OR its SLUG (e.g. a row's page-key field); both hosts resolve either. There is NO page-name lookup: a slug is the only data-carried navigation key.",
       openLink: "(link: string) => boolean",
       goBack: "() => void",
-      push: "(pageId: string, params?: object) => void",
-      replace: "(pageId: string, params?: object) => void",
+      push: "(pageIdOrSlug: string, params?: object) => void",
+      replace: "(pageIdOrSlug: string, params?: object) => void",
       back: "() => void",
       currentRoute: "{ pageId: string, params: object }",
     },
@@ -3259,7 +3269,24 @@ const CONTRACT = deepFreeze({
   //    are compressed to WebP by default; `compress: false` stores the file
   //    byte-for-byte. Existing callers are unaffected — the field is only sent
   //    when the opt-out is chosen.
-  version: "1.76.0",
+  // 1.77.0: documentation (sc-5713) — `goTo`/`push`/`replace` document that
+  //    they accept a page SLUG as well as a page UUID. Both hosts have always
+  //    resolved either (the web route reads id-or-slug; the export's
+  //    PAGE_ROUTES maps both to the screen name), but the contract said
+  //    `pageId` only, so data-driven widgets — whose rows carry slugs —
+  //    invented params patterns that navigate nowhere. No code changed shape.
+  // 1.78.0: additive (sc-5646) — `widgetStyles` carries every value shape a
+  //    `styleSchema` field can produce, not just scalars and gradients. The
+  //    Studio offers the SAME field in the widget editor and in Theme
+  //    Settings, so a structured value (a container-style overlay, a list of
+  //    ids) that persisted per instance but was dropped app-wide made one
+  //    edit behave two ways. Objects and arrays are now carried, bounded by
+  //    `themeWidgetStyles.maxValueDepth` / `maxValueEntries` /
+  //    `maxValueBytes`, with `maxBytes` capping the whole map — a ceiling the
+  //    per-scalar limits never stated, so the worst-case unauthenticated
+  //    payload is SMALLER than before. `__proto__`-style keys are refused at
+  //    every level. Additive: every value accepted before is accepted now.
+  version: "1.78.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,

package/dist/host.d.ts

@@ -45,6 +45,17 @@ export function normaliseThemeComponents(raw: unknown): ThemeComponents;
  * contract, so the authoritative field type is the widget's own styleSchema.
  * Bounded by `CONTRACT.themeWidgetStyles`.
  */
+/**
+ * sc-5646 host helper: validates ONE widget style object — a placed node's
+ * `props.style` or an app-wide `widgetStyles[id]` entry. Both scopes hold the
+ * same vocabulary, so both are validated the same way; `maxFields` applies the
+ * per-widget cap only the app-wide map needs.
+ */
+export function normaliseWidgetStyleFields(
+  raw: unknown,
+  options?: { maxFields?: number },
+): Record<string, unknown>;
+
 export function normaliseWidgetStyles(raw: unknown): ThemeWidgetStyles;
 
 /**

package/dist/host.js

@@ -18,6 +18,7 @@ export { resolveProps } from "./property-schema.js";
 // hosts, so the Player and the Expo export cannot diverge.
 export {
   normaliseThemeComponents,
+  normaliseWidgetStyleFields,
   normaliseWidgetStyles,
   applyThemeComponentStyle,
 } from "./theme-components.js";

package/dist/theme-components.cjs

@@ -99,12 +99,30 @@ function normaliseThemeComponents(raw) {
 }
 
 
+// Values are assigned onto plain object literals, so `__proto__` would set a
+// PROTOTYPE rather than a style field. Refused at every level.
+const UNSAFE_STYLE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function isUsableStyleKey(key) {
+  return (
+    typeof key === "string" &&
+    key.length > 0 &&
+    key.length <= 64 &&
+    !UNSAFE_STYLE_KEYS.has(key)
+  );
+}
+
 // REQ-THEME-ELEMENT: one value out of the per-widget map. Unlike a component
 // token, there is no declared `type` to coerce against -- the key space is the
 // workspace's widget catalog, not the contract -- so validation here is
 // STRUCTURAL. The authoritative type is the widget's own styleSchema, which the
 // Studio honours by only ever offering fields that widget declares.
-function coerceWidgetStyleValue(value) {
+//
+// sc-5646: that same field is offered per instance AND app-wide, so carrying
+// only scalars here made one edit behave two ways. A structured value rides
+// along too -- bounded by depth, width and bytes, never by trust.
+function coerceWidgetStyleValue(value, depth = 0) {
+  const { maxValueDepth, maxValueEntries } = CONTRACT.themeWidgetStyles;
   if (typeof value === "string") {
     const trimmed = value.trim();
     // Long enough for a hex, an enum value or a font name; short enough that a
@@ -113,10 +131,75 @@ function coerceWidgetStyleValue(value) {
   }
   if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
   if (typeof value === "boolean") return value;
-  if (isPlainObject(value)) return normaliseComponentGradient(value) || undefined;
+  if (depth >= maxValueDepth) return undefined;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value) {
+      if (items.length >= maxValueEntries) break;
+      const coerced = coerceWidgetStyleValue(item, depth + 1);
+      if (coerced !== undefined) items.push(coerced);
+    }
+    return items.length > 0 ? items : undefined;
+  }
+  if (isPlainObject(value)) {
+    // A gradient keeps its own normaliser -- its stops are interpolated into
+    // CSS and into generated export source, so they never ride the generic
+    // path. Claiming the grammar is enough to be held to it: an invalid one is
+    // dropped rather than carried through as a plain object.
+    if ("from" in value || "to" in value) {
+      return normaliseComponentGradient(value) || undefined;
+    }
+    const out = {};
+    let kept = 0;
+    for (const [key, item] of Object.entries(value)) {
+      if (kept >= maxValueEntries) break;
+      if (!isUsableStyleKey(key)) continue;
+      const coerced = coerceWidgetStyleValue(item, depth + 1);
+      if (coerced === undefined) continue;
+      out[key] = coerced;
+      kept += 1;
+    }
+    return kept > 0 ? out : undefined;
+  }
   return undefined;
 }
 
+// What the value actually costs the cold-start read and the baked export.
+function styleValueBytes(value) {
+  const json = JSON.stringify(value);
+  return typeof json === "string" ? json.length : Infinity;
+}
+
+/**
+ * sc-5646: ONE widget's style fields, validated. The app-wide layer and a placed
+ * node's `props.style` hold the SAME vocabulary at different scopes, so they must
+ * accept the same values — a field an author can set on a node and not app-wide
+ * (or the reverse) is exactly the divergence the two surfaces are meant not to
+ * have. The per-widget FIELD cap is deliberately not applied here: it bounds the
+ * app-wide map that rides the unauthenticated cold-start read, not one node in a
+ * page layout the builder already writes unbounded.
+ *
+ * @param {unknown} raw — a `props.style` / `widgetStyles[id]` object.
+ * @param {{ maxFields?: number }} [options]
+ * @returns {Record<string, unknown>} the fields that survived; `{}` for junk.
+ */
+function normaliseWidgetStyleFields(raw, { maxFields } = {}) {
+  if (!isPlainObject(raw)) return {};
+  const { maxValueBytes } = CONTRACT.themeWidgetStyles;
+  const out = {};
+  let count = 0;
+  for (const [field, value] of Object.entries(raw)) {
+    if (maxFields !== undefined && count >= maxFields) break;
+    if (!isUsableStyleKey(field)) continue;
+    const coerced = coerceWidgetStyleValue(value);
+    if (coerced === undefined) continue;
+    if (styleValueBytes(coerced) > maxValueBytes) continue;
+    out[field] = coerced;
+    count += 1;
+  }
+  return out;
+}
+
 /**
  * REQ-THEME-ELEMENT: validate `themeConfig.widgetStyles` -- app-wide style values
  * keyed by WIDGET MANIFEST ID, then by that widget's own styleSchema field name.
@@ -132,26 +215,31 @@ function coerceWidgetStyleValue(value) {
  */
 function normaliseWidgetStyles(raw) {
   if (!isPlainObject(raw)) return {};
-  const { maxWidgets, maxFieldsPerWidget } = CONTRACT.themeWidgetStyles;
+  const { maxWidgets, maxFieldsPerWidget, maxBytes } =
+    CONTRACT.themeWidgetStyles;
   const idPattern = CONTRACT.manifestSchema.id.pattern;
   const out = {};
   let widgets = 0;
+  let bytes = 0;
   for (const [manifestId, fields] of Object.entries(raw)) {
     if (widgets >= maxWidgets) break;
     if (!idPattern.test(manifestId) || !isPlainObject(fields)) continue;
-    const kept = {};
-    let count = 0;
-    for (const [field, value] of Object.entries(fields)) {
-      if (count >= maxFieldsPerWidget) break;
-      const coerced = coerceWidgetStyleValue(value);
-      if (coerced === undefined) continue;
-      kept[field] = coerced;
-      count += 1;
-    }
+    // The SAME per-field validation a placed node's style gets, plus the cap
+    // that only this map needs.
+    const kept = normaliseWidgetStyleFields(fields, {
+      maxFields: maxFieldsPerWidget,
+    });
+    const count = Object.keys(kept).length;
     // An emptied entry is dropped rather than persisted as `{}`, mirroring
     // normaliseThemeComponents.
     if (count === 0) continue;
+    // Whole entries, never half of one: a widget rendering with SOME of its
+    // app-wide fields reads as a bug, where one rendering with none reads as
+    // "not styled yet".
+    const entryBytes = styleValueBytes(kept) + manifestId.length;
+    if (bytes + entryBytes > maxBytes) break;
     out[manifestId] = kept;
+    bytes += entryBytes;
     widgets += 1;
   }
   return out;
@@ -245,4 +333,4 @@ function applyThemeComponentStyle(manifestId, theme, props, styleSchema) {
   return { ...base, style: { ...themed, ...authored } };
 }
 
-module.exports = { normaliseThemeComponents, normaliseWidgetStyles, applyThemeComponentStyle };
+module.exports = { normaliseThemeComponents, normaliseWidgetStyleFields, normaliseWidgetStyles, applyThemeComponentStyle };

package/dist/theme-components.js

@@ -91,12 +91,30 @@ export function normaliseThemeComponents(raw) {
 }
 
 
+// Values are assigned onto plain object literals, so `__proto__` would set a
+// PROTOTYPE rather than a style field. Refused at every level.
+const UNSAFE_STYLE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function isUsableStyleKey(key) {
+  return (
+    typeof key === "string" &&
+    key.length > 0 &&
+    key.length <= 64 &&
+    !UNSAFE_STYLE_KEYS.has(key)
+  );
+}
+
 // REQ-THEME-ELEMENT: one value out of the per-widget map. Unlike a component
 // token, there is no declared `type` to coerce against -- the key space is the
 // workspace's widget catalog, not the contract -- so validation here is
 // STRUCTURAL. The authoritative type is the widget's own styleSchema, which the
 // Studio honours by only ever offering fields that widget declares.
-function coerceWidgetStyleValue(value) {
+//
+// sc-5646: that same field is offered per instance AND app-wide, so carrying
+// only scalars here made one edit behave two ways. A structured value rides
+// along too -- bounded by depth, width and bytes, never by trust.
+function coerceWidgetStyleValue(value, depth = 0) {
+  const { maxValueDepth, maxValueEntries } = CONTRACT.themeWidgetStyles;
   if (typeof value === "string") {
     const trimmed = value.trim();
     // Long enough for a hex, an enum value or a font name; short enough that a
@@ -105,10 +123,75 @@ function coerceWidgetStyleValue(value) {
   }
   if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
   if (typeof value === "boolean") return value;
-  if (isPlainObject(value)) return normaliseComponentGradient(value) || undefined;
+  if (depth >= maxValueDepth) return undefined;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value) {
+      if (items.length >= maxValueEntries) break;
+      const coerced = coerceWidgetStyleValue(item, depth + 1);
+      if (coerced !== undefined) items.push(coerced);
+    }
+    return items.length > 0 ? items : undefined;
+  }
+  if (isPlainObject(value)) {
+    // A gradient keeps its own normaliser -- its stops are interpolated into
+    // CSS and into generated export source, so they never ride the generic
+    // path. Claiming the grammar is enough to be held to it: an invalid one is
+    // dropped rather than carried through as a plain object.
+    if ("from" in value || "to" in value) {
+      return normaliseComponentGradient(value) || undefined;
+    }
+    const out = {};
+    let kept = 0;
+    for (const [key, item] of Object.entries(value)) {
+      if (kept >= maxValueEntries) break;
+      if (!isUsableStyleKey(key)) continue;
+      const coerced = coerceWidgetStyleValue(item, depth + 1);
+      if (coerced === undefined) continue;
+      out[key] = coerced;
+      kept += 1;
+    }
+    return kept > 0 ? out : undefined;
+  }
   return undefined;
 }
 
+// What the value actually costs the cold-start read and the baked export.
+function styleValueBytes(value) {
+  const json = JSON.stringify(value);
+  return typeof json === "string" ? json.length : Infinity;
+}
+
+/**
+ * sc-5646: ONE widget's style fields, validated. The app-wide layer and a placed
+ * node's `props.style` hold the SAME vocabulary at different scopes, so they must
+ * accept the same values — a field an author can set on a node and not app-wide
+ * (or the reverse) is exactly the divergence the two surfaces are meant not to
+ * have. The per-widget FIELD cap is deliberately not applied here: it bounds the
+ * app-wide map that rides the unauthenticated cold-start read, not one node in a
+ * page layout the builder already writes unbounded.
+ *
+ * @param {unknown} raw — a `props.style` / `widgetStyles[id]` object.
+ * @param {{ maxFields?: number }} [options]
+ * @returns {Record<string, unknown>} the fields that survived; `{}` for junk.
+ */
+export function normaliseWidgetStyleFields(raw, { maxFields } = {}) {
+  if (!isPlainObject(raw)) return {};
+  const { maxValueBytes } = CONTRACT.themeWidgetStyles;
+  const out = {};
+  let count = 0;
+  for (const [field, value] of Object.entries(raw)) {
+    if (maxFields !== undefined && count >= maxFields) break;
+    if (!isUsableStyleKey(field)) continue;
+    const coerced = coerceWidgetStyleValue(value);
+    if (coerced === undefined) continue;
+    if (styleValueBytes(coerced) > maxValueBytes) continue;
+    out[field] = coerced;
+    count += 1;
+  }
+  return out;
+}
+
 /**
  * REQ-THEME-ELEMENT: validate `themeConfig.widgetStyles` -- app-wide style values
  * keyed by WIDGET MANIFEST ID, then by that widget's own styleSchema field name.
@@ -124,26 +207,31 @@ function coerceWidgetStyleValue(value) {
  */
 export function normaliseWidgetStyles(raw) {
   if (!isPlainObject(raw)) return {};
-  const { maxWidgets, maxFieldsPerWidget } = CONTRACT.themeWidgetStyles;
+  const { maxWidgets, maxFieldsPerWidget, maxBytes } =
+    CONTRACT.themeWidgetStyles;
   const idPattern = CONTRACT.manifestSchema.id.pattern;
   const out = {};
   let widgets = 0;
+  let bytes = 0;
   for (const [manifestId, fields] of Object.entries(raw)) {
     if (widgets >= maxWidgets) break;
     if (!idPattern.test(manifestId) || !isPlainObject(fields)) continue;
-    const kept = {};
-    let count = 0;
-    for (const [field, value] of Object.entries(fields)) {
-      if (count >= maxFieldsPerWidget) break;
-      const coerced = coerceWidgetStyleValue(value);
-      if (coerced === undefined) continue;
-      kept[field] = coerced;
-      count += 1;
-    }
+    // The SAME per-field validation a placed node's style gets, plus the cap
+    // that only this map needs.
+    const kept = normaliseWidgetStyleFields(fields, {
+      maxFields: maxFieldsPerWidget,
+    });
+    const count = Object.keys(kept).length;
     // An emptied entry is dropped rather than persisted as `{}`, mirroring
     // normaliseThemeComponents.
     if (count === 0) continue;
+    // Whole entries, never half of one: a widget rendering with SOME of its
+    // app-wide fields reads as a bug, where one rendering with none reads as
+    // "not styled yet".
+    const entryBytes = styleValueBytes(kept) + manifestId.length;
+    if (bytes + entryBytes > maxBytes) break;
     out[manifestId] = kept;
+    bytes += entryBytes;
     widgets += 1;
   }
   return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colixsystems/widget-sdk",
-  "version": "0.102.0",
+  "version": "0.103.0",
   "description": "Common widget interface for AppStudio. Implements WidgetManifest, WidgetContext, property schema, and helper hooks.",
   "type": "module",
   "main": "./dist/index.js",