@colixsystems/widget-sdk 0.200.0 → 0.202.0

package/README.md

@@ -83,7 +83,75 @@ See the design reference for the full architecture: [`docs/architecture/widget-m
 
 ## Status
 
-`v0.200.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.202.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.202.0 (contract 1.161.0)
+
+**Themed collapsible sections: `Accordion` and `AccordionItem`.** Widgets each built their own expand/collapse section, with their own header, chevron and spacing, and none told a screen reader whether the section was open. The SDK now draws one, from the app's existing look: the surface from **Theme Settings > Cards** (background, border, corner radius) and the headers and dividers from **Theme Settings > Lists** (row padding, row height, divider). No new theme scope.
+
+```jsx
+<Accordion defaultValue="shipping">
+  <AccordionItem value="shipping" title="Shipping" subtitle="2-4 days">
+    <Text>…</Text>
+  </AccordionItem>
+  <AccordionItem value="returns" title="Returns" trailing={<Badge label="New" tone="info" />}>
+    <Text>…</Text>
+  </AccordionItem>
+</Accordion>
+```
+
+By default one section is open at a time and pressing the open one closes it; `multiple` lets several stay open. Pass `value` + `onChange` to control it (a key, or an array of keys when `multiple`), or `defaultValue` to leave it uncontrolled. Each header is a 44px button with a chevron that works from the keyboard and reports `aria-expanded`. `trailing` sits outside the header's toggle, so a button there runs its own action. A section's body mounts only while it is open, so fetch its data inside it. One view renders on both the web Player and the exported app. Additive.
+
+### What's new in 0.201.0 (contract 1.160.0)
+
+**A page badge can stay live while its page is closed — `manifest.badgeCounter` + `useBadgeCount(props)`.** `usePageBadge` only runs while your widget is on screen, so a chat's unread count used to reach the menu only after someone opened the chat's page. Declare `badgeCounter: true` and export a counting hook from every platform entry, and the app runs it in the background for each placement on a page its menu links to (installed marketplace widgets, your workspace's own included):
+
+```jsx
+import { useMemo } from "react";
+import {
+  useDatastoreQuery,
+  useDatastoreSubscription,
+  usePageBadge,
+  useStableQuery,
+  useUser,
+} from "@colixsystems/widget-sdk";
+
+function useOpenTasks({ tasksTableId }) {
+  const me = useUser().id;
+  const table = me ? tasksTableId : null;
+  const { data, loading, refetch } = useDatastoreQuery(
+    table,
+    useStableQuery(() => ({ filter: { Assignee: "eq:me", Done: "eq:false" }, limit: 500 })),
+  );
+  // Stay live while the page is closed: re-read whenever a task changes.
+  const handlers = useMemo(
+    () => ({ onCreated: refetch, onUpdated: refetch, onDeleted: refetch }),
+    [refetch],
+  );
+  useDatastoreSubscription(table, handlers);
+  return loading ? null : data.length;
+}
+
+// The host runs this while the page is closed.
+export function useBadgeCount(props) {
+  return useOpenTasks(props);
+}
+
+export default function TaskList(props) {
+  usePageBadge(useOpenTasks(props));
+  // ...
+}
+```
+
+- **The hook** is called with the placement's resolved props, inside the widget's own context. Return a whole number, or `null` while the count is not known yet. It must only read: no rendering, no data writes, no navigation, no events or toasts, nothing marked read, and no `usePageBadge`, `useScreenTitle`, `useSectionEmpty` or `useWidgetRoute` setter.
+- **The host enforces read-only.** A counter's datastore and directory offer only their read methods and realtime subscriptions, and notification mutes only `get`/`list`. Writes, typing signals, payments, `notifications.send`, files, assets, AI agents, translation, link previews, device capabilities, identification and account actions all answer as unavailable, exactly as on a host that does not provide them.
+- **Stay live.** The counter runs for as long as the app is open, so subscribe to changes (as above) or refetch on a slow interval; a counter that reads once goes stale.
+- **Share one implementation.** Count with the same function the widget badges with, so the background count and the open widget never disagree.
+- **`usePageBadge(null)` is a new signal.** An explicit `null` means "not known yet": nothing is written and the current badge stays. Pass `null` until your first load settles, so opening the page never flashes the badge to 0. `undefined`, `0` and any other value that is not a positive number still clear this widget's share, exactly as before, so `usePageBadge(data?.count)` behaves as it always has.
+- **New linter rules.** `badge-counter-export-missing` (error) refuses a widget that declares `badgeCounter` while an entry has no `useBadgeCount` export; `badge-counter-undeclared` (warning) flags the export without the declaration. The export name is published as `CONTRACT.badgeCounterExport`.
+- **Types:** `WidgetManifest.badgeCounter` and `BadgeCounterHook`.
+
+Additive: a widget without `badgeCounter` is unaffected.
 
 ### What's new in 0.200.0 (contract 1.159.0)
 
@@ -2342,6 +2410,7 @@ import { defineWidget, validateManifest, useDatastoreQuery, Text, View } from "@
 - `List`, `ListRow`, `ListHeader`, `EmptyState` — the themed list building blocks. `<ListRow title subtitle leading trailing onPress selected divider>` draws one record row from the theme's `list` scope (padding, height, gap, radius, background, divider); `<List>` spaces its rows and hands overrides down; `<ListHeader>` labels a table's columns on the rows' own inset; `<EmptyState icon title message>` is the "nothing here" panel. Never hand-roll a row or a header row from `View` + `Pressable`.
 - `Badge`, `Avatar`, `Progress`, `Stat`, `Divider` — the themed status pill, person picture, completion bar or ring, headline figure and rule the built-in widgets of the same names render through. Reach for them inside a record row instead of hand-rolling a pill or a circle from `View`.
 - `Card`, `Button`, `TextField` — the themed card surface, button and text field the built-in widgets render through. With no props each takes the app's look from Theme Settings (Cards, Buttons, Muted); never hand-roll one from `View` / `Pressable` / a bare `TextInput`.
+- `Accordion`, `AccordionItem` — themed collapsible sections. `<Accordion><AccordionItem title subtitle trailing>…</AccordionItem></Accordion>` draws its surface from the theme's `card` scope and its headers and dividers from the `list` scope; one section open at a time, or `multiple`. Never hand-roll a collapsible from `Pressable` + a chevron.
 - `Tabs` — the themed tab strip. `<Tabs items value onChange>` draws a segmented control, pills or an underline as the theme's `tabs` scope says; render the selected panel yourself. Never hand-roll tabs from `Pressable` chips.
 - `textRoleStyle(role, typography, colors)`, `TEXT_ROLES` — the style of a semantic text tier, shared with the built-in widgets.
 - `WidgetContextProvider` — React context provider that the host (Studio, Player, exported app) wraps widgets with.

package/dist/accordion-tokens.js

@@ -0,0 +1,54 @@
+// The values `<Accordion>` paints with, and its open-state rules. The surface
+// comes from the theme's `card` scope and the rows from its `list` scope, so a
+// look restyles every collapsible section without a scope of its own.
+// Platform-free, so both hosts draw from the same numbers and tests can pin
+// them without a renderer.
+
+import { DEFAULT_THEME_TOKENS } from "./_theme-tokens.js";
+import { mixHex, isHexColor } from "./contract.js";
+import { normaliseThemeComponents } from "./theme-components.js";
+import { resolveListTokens, LIST_ROW_MIN_HEIGHT } from "./list-tokens.js";
+
+/**
+ * Resolve one accordion: the `card` scope's surface, the `list` scope's row
+ * padding, height and divider, then the theme tokens.
+ *
+ * @param {object} theme — the resolved workspace theme (`useTheme()` shape).
+ */
+export function resolveAccordionTokens(theme) {
+  const base = theme && typeof theme === "object" ? theme : DEFAULT_THEME_TOKENS;
+  const colors = base.colors || DEFAULT_THEME_TOKENS.colors;
+  const radii = base.radii || DEFAULT_THEME_TOKENS.radii;
+  const card = normaliseThemeComponents(base.components).card || {};
+  const list = resolveListTokens(base);
+
+  const background = card.background ?? colors.surface;
+  return {
+    background,
+    borderColor: card.borderColor ?? colors.border,
+    radius: card.radius ?? radii.md,
+    headerPadding: list.rowPadding,
+    // A dense look may shrink a row, never the header's tap target.
+    headerMinHeight: Math.max(list.rowMinHeight, LIST_ROW_MIN_HEIGHT),
+    dividerColor: list.dividerColor,
+    dividerWidth: list.dividerWidth,
+    // The mix needs hex; a translucent surface tints the theme's own instead.
+    pressedBackground: mixHex(colors.onSurface, isHexColor(background) ? background : colors.surface, 0.94),
+    chevronColor: colors.onSurfaceMuted,
+  };
+}
+
+/** The open sections as an array, from a single key or a list of keys. */
+export function openKeysOf(value) {
+  if (Array.isArray(value)) return value.filter((key) => key !== null && key !== undefined);
+  return value === null || value === undefined ? [] : [value];
+}
+
+/**
+ * The open sections after one header is pressed. Single mode keeps at most one
+ * open, and pressing the open one closes it.
+ */
+export function toggleOpenKey(open, key, multiple) {
+  if (open.includes(key)) return open.filter((k) => k !== key);
+  return multiple ? [...open, key] : [key];
+}

package/dist/accordion-view.js

@@ -0,0 +1,210 @@
+// The ONE implementation behind the `<Accordion>` and `<AccordionItem>` SDK
+// primitives. The platform bindings (`accordion.js` / `accordion.native.js`)
+// differ only in where the primitives come from, so the hosts cannot drift.
+//
+// Widgets each built their own collapsible section, with their own header,
+// chevron and spacing, and none announced whether it was open. This one reads
+// the theme's `card` and `list` scopes, so every section in an app matches.
+
+import React from "react";
+import { useHostTheme } from "./hooks.js";
+import { DEFAULT_THEME_TOKENS } from "./_theme-tokens.js";
+import { Icon } from "./icon.js";
+import { textRoleStyle } from "./text-roles.js";
+import { resolveAccordionTokens, openKeysOf, toggleOpenKey } from "./accordion-tokens.js";
+
+/**
+ * Bind the shared accordion to one platform's primitives.
+ *
+ * @param {{View: any, Text: any, Pressable: any}} rn
+ */
+export function makeAccordion(rn) {
+  const { View, Text, Pressable } = rn;
+  const AccordionContext = React.createContext(null);
+
+  /**
+   * @param {boolean} [props.multiple] — several sections may be open at once.
+   * @param {string|string[]|null} [props.value] — the open section(s); makes
+   *   the accordion controlled. A key in single mode, an array in multiple.
+   * @param {string|string[]|null} [props.defaultValue] — the initially open
+   *   section(s) when uncontrolled.
+   * @param {(next: string|string[]|null) => void} [props.onChange] — the open
+   *   section(s) after a header press, in the same shape as `value`.
+   */
+  function Accordion({
+    multiple = false,
+    value,
+    defaultValue,
+    onChange,
+    children,
+    accessibilityLabel,
+    style,
+    testID,
+  }) {
+    const theme = useHostTheme() || DEFAULT_THEME_TOKENS;
+    const tokens = resolveAccordionTokens(theme);
+    const controlled = value !== undefined;
+    const [ownOpen, setOwnOpen] = React.useState(() => openKeysOf(defaultValue));
+    const open = controlled ? openKeysOf(value) : ownOpen;
+
+    const toggle = (key) => {
+      if (key === null || key === undefined) return;
+      const next = toggleOpenKey(open, key, multiple);
+      if (!controlled) setOwnOpen(next);
+      if (typeof onChange === "function") onChange(multiple ? next : (next[0] ?? null));
+    };
+
+    return React.createElement(
+      AccordionContext.Provider,
+      { value: { open, toggle, tokens, theme } },
+      React.createElement(
+        View,
+        {
+          style: [
+            {
+              backgroundColor: tokens.background,
+              borderColor: tokens.borderColor,
+              borderWidth: 1,
+              borderRadius: tokens.radius,
+              overflow: "hidden",
+            },
+            style,
+          ],
+          // A label names the group only when it has a role to hang on.
+          role: accessibilityLabel ? "group" : undefined,
+          accessibilityLabel,
+          testID,
+        },
+        // The last section's divider slides under the clipped edge, so it
+        // ends on the surface wherever it sits in the tree.
+        React.createElement(
+          View,
+          { style: { marginBottom: -tokens.dividerWidth } },
+          children,
+        ),
+      ),
+    );
+  }
+  Accordion.displayName = "Accordion";
+
+  function AccordionItem(props) {
+    const context = React.useContext(AccordionContext);
+    // Stable per section, so a wrapped or conditional one keeps its own key.
+    const ownKey = React.useId();
+    // A lone section is an accordion of one, so it still opens and closes.
+    if (!context) return React.createElement(Accordion, null, React.createElement(AccordionItem, props));
+
+    const {
+      value = ownKey,
+      title,
+      subtitle,
+      trailing,
+      disabled = false,
+      divider = true,
+      children,
+      accessibilityLabel,
+      style,
+      testID,
+    } = props;
+    const { open: openKeys, toggle, tokens, theme } = context;
+    const open = openKeys.includes(value);
+    const { colors, typography } = theme;
+
+    const header = React.createElement(
+      View,
+      {
+        style: {
+          flexDirection: "row",
+          alignItems: "center",
+          paddingRight: trailing ? tokens.headerPadding : 0,
+        },
+      },
+      React.createElement(
+        Pressable,
+        {
+          onPress: () => toggle(value),
+          disabled,
+          // accessibilityRole + aria-*: the pair that announces on both hosts.
+          accessibilityRole: "button",
+          accessibilityLabel: accessibilityLabel ?? headerLabel(title, subtitle),
+          "aria-expanded": open,
+          "aria-disabled": disabled,
+          testID: testID ? `${testID}-header` : undefined,
+          style: ({ pressed }) => [
+            {
+              flex: 1,
+              minWidth: 0,
+              flexDirection: "row",
+              alignItems: "center",
+              gap: theme.spacing.sm,
+              minHeight: tokens.headerMinHeight,
+              padding: tokens.headerPadding,
+            },
+            pressed ? { backgroundColor: tokens.pressedBackground } : null,
+            disabled ? { opacity: 0.5 } : null,
+          ],
+        },
+        React.createElement(Icon, {
+          name: open ? "chevron-down" : "chevron-right",
+          size: 18,
+          color: tokens.chevronColor,
+        }),
+        React.createElement(
+          View,
+          { style: { flex: 1, minWidth: 0, gap: 2 } },
+          title !== undefined && title !== null
+            ? React.createElement(
+                Text,
+                { style: textRoleStyle("subtitle", typography, colors), numberOfLines: 1 },
+                title,
+              )
+            : null,
+          subtitle !== undefined && subtitle !== null
+            ? React.createElement(
+                Text,
+                { style: textRoleStyle("caption", typography, colors), numberOfLines: 2 },
+                subtitle,
+              )
+            : null,
+        ),
+      ),
+      // Outside the toggle, so a button here never opens the section.
+      trailing || null,
+    );
+
+    return React.createElement(
+      View,
+      {
+        style: [
+          divider && tokens.dividerWidth > 0
+            ? { borderBottomWidth: tokens.dividerWidth, borderColor: tokens.dividerColor }
+            : null,
+          style,
+        ],
+        testID,
+      },
+      header,
+      // Mounted only while open, so a closed section costs nothing.
+      open
+        ? React.createElement(
+            View,
+            {
+              style: { padding: tokens.headerPadding, paddingTop: 0 },
+              testID: testID ? `${testID}-panel` : undefined,
+            },
+            // A section nested in this body is not one of this accordion's.
+            React.createElement(AccordionContext.Provider, { value: null }, children),
+          )
+        : null,
+    );
+  }
+  AccordionItem.displayName = "AccordionItem";
+
+  // The label replaces the visible text, so it must carry the subtitle too.
+  function headerLabel(title, subtitle) {
+    const parts = [title, subtitle].filter((part) => typeof part === "string" && part !== "");
+    return parts.length ? parts.join(", ") : undefined;
+  }
+
+  return { Accordion, AccordionItem };
+}

package/dist/accordion.js

@@ -0,0 +1,7 @@
+// `<Accordion>` / `<AccordionItem>` (web). Binds ./accordion-view.js to
+// react-native-web; see ./primitives.js for why not the bare specifier.
+
+import { View, Text, Pressable } from "react-native-web";
+import { makeAccordion } from "./accordion-view.js";
+
+export const { Accordion, AccordionItem } = makeAccordion({ View, Text, Pressable });

package/dist/accordion.native.js

@@ -0,0 +1,7 @@
+// `<Accordion>` / `<AccordionItem>` (native). Binds ./accordion-view.js to
+// React Native's own primitives; only the import differs from ./accordion.js.
+
+import { View, Text, Pressable } from "react-native";
+import { makeAccordion } from "./accordion-view.js";
+
+export const { Accordion, AccordionItem } = makeAccordion({ View, Text, Pressable });

package/dist/contract.cjs

@@ -1065,7 +1065,10 @@ const HOOKS = [
     description:
       "Puts count on the menu entry or tab of the page this widget is on (a chat's unread messages, open tasks). " +
       "The host sums every widget on the page and keeps the last count after the widget leaves the screen, until it " +
-      "reports again; 0, or anything not a positive number, clears this widget's share. Returns { supported }: false " +
+      "reports again; 0, undefined, or any other value that is not a positive number, clears this widget's share. " +
+      "An explicit null means the count is not known yet and keeps the current badge (pass null until the first load " +
+      "settles, so the badge never flashes to 0). manifest.badgeCounter keeps the badge live while the page is closed; " +
+      "see that field for who may declare it. Returns { supported }: false " +
       "on a host without page badges (the Builder canvas), where it does nothing. Call it at render with the current " +
       "count, never in a loop. Backed by ctx.navigation.setBadge. Identical on web (Player) and the Expo export.",
     returnShape: {
@@ -1447,7 +1450,7 @@ const HOOKS = [
       message: "string | null",
       signerName: "string | null",
       signedAt: "string | null",
-      verdict: "{ valid, checks, content_status, ... } | null",
+      verdict: "{ valid, checks, content_status, signed_by_others_since, seal, ... } | null",
       loading: "boolean",
       error: "PermissionError | null  // { code, message, retryable }",
       initiate: "() => Promise<{ signature_id, qr, auto_start_token, status }>",
@@ -2801,6 +2804,20 @@ const PRIMITIVES = [
     rnComponent: null,
     docsUrl: null,
   },
+  {
+    name: "Accordion",
+    description:
+      'Themed collapsible sections. `<Accordion defaultValue="shipping"><AccordionItem value="shipping" title="Shipping" subtitle="2-4 days">…</AccordionItem><AccordionItem value="returns" title="Returns">…</AccordionItem></Accordion>`. THE way to build a section that expands and collapses (an FAQ, a settings group, a record\'s details, a group whose members show on demand): the surface takes the app\'s card look (Theme Settings > Cards: background, border, corner radius) and the headers and dividers its list look (Theme Settings > Lists: row padding, row height, divider), so every collapsible section in the app matches. Each header has a chevron, a 44px touch target, works from the keyboard and tells assistive technology whether its section is open, so never hand-roll a collapsible from `Pressable` + a chevron + a `useState`. By default one section is open at a time and pressing the open one closes it; `multiple` lets several stay open. Props: `multiple`, `value` (the open key, or an array of keys when `multiple`; makes it controlled), `defaultValue` (the same shape, uncontrolled), `onChange(next)` (the open key(s) after a press, in the same shape), `accessibilityLabel`, `style`, `testID`. Its children are `<AccordionItem>`s.',
+    rnComponent: null,
+    docsUrl: null,
+  },
+  {
+    name: "AccordionItem",
+    description:
+      'One section of an `<Accordion>`. `<AccordionItem value={group.id} title={group.name} subtitle={`${group.count} members`} trailing={<Button title="Delete" variant="danger" onPress={remove} />}>…</AccordionItem>`. Props: `value` (the key `value` / `defaultValue` / `onChange` name it by — give one whenever you name sections; an item may sit inside your own component or a fragment), `title`, `subtitle` (the subtitle / caption text tiers), `trailing` (a node beside the header and OUTSIDE its toggle, so a button there runs its own action without opening the section), `disabled`, `divider` (default true; the surface edge hides the rule under the last section), `children` (the body: it mounts only while the section is open, so fetch its data inside it; an `<AccordionItem>` placed in a body is its own section, never part of the outer accordion), `accessibilityLabel` (defaults to the string `title` and `subtitle`), `style`, `testID` (also tags the header `<testID>-header` and the open body `<testID>-panel`). On its own, outside an `<Accordion>`, it is an accordion of one.',
+    rnComponent: null,
+    docsUrl: null,
+  },
   {
     name: "Tabs",
     description:
@@ -3047,6 +3064,13 @@ const MANIFEST_SCHEMA = {
       "Optional (default false). TRUE when the widget draws a strip of live figures (counts, totals, averages) about the records it shows, or is itself a strip of figures. The AppStudio app-builder reads this when it places an already-installed widget: it counts the widget as the page's figures, so it does not plan a second strip of figures beside it. Set it to match what the component actually renders; leave it false (or omit) when the widget draws no figures.",
     default: false,
   },
+  badgeCounter: {
+    type: "boolean",
+    required: false,
+    description:
+      "Optional (default false). TRUE when every platform entry also exports useBadgeCount(props): a hook returning the count the widget puts on its page's menu entry with usePageBadge, so the app keeps that badge live while the page is closed. The host runs counters for installed marketplace widgets (the workspace's own published widgets included); the platform's built-in widgets declare none. It calls the hook with the instance's resolved props, inside the widget's own context; the hook returns a whole number, or null while the count is not known yet. It only reads, and the host enforces that: the counter's datastore and directory expose only their read methods (plus realtime subscriptions) and notification mutes only get/list, while writes, typing signals, payments, notifications.send, files, assets, AI agents, translation, link previews, device capabilities, identification and account actions all answer as unavailable. It also renders nothing, navigates nowhere, emits no events or toasts, marks nothing read, and calls none of usePageBadge, useScreenTitle, useSectionEmpty or useWidgetRoute's setter. The linter refuses a declared counter whose entry has no useBadgeCount export. The AppStudio widget agent leaves this unset: a generated widget never declares a badge counter.",
+    default: false,
+  },
   events: {
     type: "object[]",
     required: true,
@@ -5305,7 +5329,17 @@ const CONTRACT = deepFreeze({
   //    flat `assets/` directory (`bundledAssets`, within `packageMaxBytes`).
   //    New `useBundledAsset(fileName)` resolves one through the new
   //    `widget.assets` map; linter rule `bundled-asset-missing` (error).
-  version: "1.159.0",
+  // 1.160.0: additive (sc-10829) — optional manifest field `badgeCounter`:
+  //    the entry exports `useBadgeCount(props)` (name in `badgeCounterExport`)
+  //    and the host runs it while the widget's page is closed, so the page
+  //    badge stays live; the host gives a counter a read-only context.
+  //    `usePageBadge(null)` now means "not known yet" and keeps the current
+  //    badge; `undefined` still clears it. Linter rules `badge-counter-export-missing`
+  //    (error) and `badge-counter-undeclared` (warning).
+  // 1.161.0: additive (sc-10930) — `Accordion` / `AccordionItem`, themed
+  //    collapsible sections drawn from the `card` and `list` scopes: single
+  //    or multiple open, controlled or uncontrolled, `aria-expanded` headers.
+  version: "1.161.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -5331,6 +5365,8 @@ const CONTRACT = deepFreeze({
   themeWidgetStyles: THEME_WIDGET_STYLES,
   widgetContextShape: WIDGET_CONTEXT_SHAPE,
   bundleExportContract: BUNDLE_EXPORT_CONTRACT,
+  // sc-10829 — the hook a `badgeCounter: true` entry exports by name.
+  badgeCounterExport: "useBadgeCount",
   bannedApis: BANNED_APIS,
   vettedImports: VETTED_IMPORTS,
   allowedBareImports: ALLOWED_BARE_IMPORTS,

package/dist/contract.js

@@ -1065,7 +1065,10 @@ const HOOKS = [
     description:
       "Puts count on the menu entry or tab of the page this widget is on (a chat's unread messages, open tasks). " +
       "The host sums every widget on the page and keeps the last count after the widget leaves the screen, until it " +
-      "reports again; 0, or anything not a positive number, clears this widget's share. Returns { supported }: false " +
+      "reports again; 0, undefined, or any other value that is not a positive number, clears this widget's share. " +
+      "An explicit null means the count is not known yet and keeps the current badge (pass null until the first load " +
+      "settles, so the badge never flashes to 0). manifest.badgeCounter keeps the badge live while the page is closed; " +
+      "see that field for who may declare it. Returns { supported }: false " +
       "on a host without page badges (the Builder canvas), where it does nothing. Call it at render with the current " +
       "count, never in a loop. Backed by ctx.navigation.setBadge. Identical on web (Player) and the Expo export.",
     returnShape: {
@@ -1447,7 +1450,7 @@ const HOOKS = [
       message: "string | null",
       signerName: "string | null",
       signedAt: "string | null",
-      verdict: "{ valid, checks, content_status, ... } | null",
+      verdict: "{ valid, checks, content_status, signed_by_others_since, seal, ... } | null",
       loading: "boolean",
       error: "PermissionError | null  // { code, message, retryable }",
       initiate: "() => Promise<{ signature_id, qr, auto_start_token, status }>",
@@ -2801,6 +2804,20 @@ const PRIMITIVES = [
     rnComponent: null,
     docsUrl: null,
   },
+  {
+    name: "Accordion",
+    description:
+      'Themed collapsible sections. `<Accordion defaultValue="shipping"><AccordionItem value="shipping" title="Shipping" subtitle="2-4 days">…</AccordionItem><AccordionItem value="returns" title="Returns">…</AccordionItem></Accordion>`. THE way to build a section that expands and collapses (an FAQ, a settings group, a record\'s details, a group whose members show on demand): the surface takes the app\'s card look (Theme Settings > Cards: background, border, corner radius) and the headers and dividers its list look (Theme Settings > Lists: row padding, row height, divider), so every collapsible section in the app matches. Each header has a chevron, a 44px touch target, works from the keyboard and tells assistive technology whether its section is open, so never hand-roll a collapsible from `Pressable` + a chevron + a `useState`. By default one section is open at a time and pressing the open one closes it; `multiple` lets several stay open. Props: `multiple`, `value` (the open key, or an array of keys when `multiple`; makes it controlled), `defaultValue` (the same shape, uncontrolled), `onChange(next)` (the open key(s) after a press, in the same shape), `accessibilityLabel`, `style`, `testID`. Its children are `<AccordionItem>`s.',
+    rnComponent: null,
+    docsUrl: null,
+  },
+  {
+    name: "AccordionItem",
+    description:
+      'One section of an `<Accordion>`. `<AccordionItem value={group.id} title={group.name} subtitle={`${group.count} members`} trailing={<Button title="Delete" variant="danger" onPress={remove} />}>…</AccordionItem>`. Props: `value` (the key `value` / `defaultValue` / `onChange` name it by — give one whenever you name sections; an item may sit inside your own component or a fragment), `title`, `subtitle` (the subtitle / caption text tiers), `trailing` (a node beside the header and OUTSIDE its toggle, so a button there runs its own action without opening the section), `disabled`, `divider` (default true; the surface edge hides the rule under the last section), `children` (the body: it mounts only while the section is open, so fetch its data inside it; an `<AccordionItem>` placed in a body is its own section, never part of the outer accordion), `accessibilityLabel` (defaults to the string `title` and `subtitle`), `style`, `testID` (also tags the header `<testID>-header` and the open body `<testID>-panel`). On its own, outside an `<Accordion>`, it is an accordion of one.',
+    rnComponent: null,
+    docsUrl: null,
+  },
   {
     name: "Tabs",
     description:
@@ -3043,6 +3060,13 @@ const MANIFEST_SCHEMA = {
       "Optional (default false). TRUE when the widget draws a strip of live figures (counts, totals, averages) about the records it shows, or is itself a strip of figures. The AppStudio app-builder reads this when it places an already-installed widget: it counts the widget as the page's figures, so it does not plan a second strip of figures beside it. Set it to match what the component actually renders; leave it false (or omit) when the widget draws no figures.",
     default: false,
   },
+  badgeCounter: {
+    type: "boolean",
+    required: false,
+    description:
+      "Optional (default false). TRUE when every platform entry also exports useBadgeCount(props): a hook returning the count the widget puts on its page's menu entry with usePageBadge, so the app keeps that badge live while the page is closed. The host runs counters for installed marketplace widgets (the workspace's own published widgets included); the platform's built-in widgets declare none. It calls the hook with the instance's resolved props, inside the widget's own context; the hook returns a whole number, or null while the count is not known yet. It only reads, and the host enforces that: the counter's datastore and directory expose only their read methods (plus realtime subscriptions) and notification mutes only get/list, while writes, typing signals, payments, notifications.send, files, assets, AI agents, translation, link previews, device capabilities, identification and account actions all answer as unavailable. It also renders nothing, navigates nowhere, emits no events or toasts, marks nothing read, and calls none of usePageBadge, useScreenTitle, useSectionEmpty or useWidgetRoute's setter. The linter refuses a declared counter whose entry has no useBadgeCount export. The AppStudio widget agent leaves this unset: a generated widget never declares a badge counter.",
+    default: false,
+  },
   events: {
     type: "object[]",
     required: true,
@@ -5301,7 +5325,17 @@ const CONTRACT = deepFreeze({
   //    flat `assets/` directory (`bundledAssets`, within `packageMaxBytes`).
   //    New `useBundledAsset(fileName)` resolves one through the new
   //    `widget.assets` map; linter rule `bundled-asset-missing` (error).
-  version: "1.159.0",
+  // 1.160.0: additive (sc-10829) — optional manifest field `badgeCounter`:
+  //    the entry exports `useBadgeCount(props)` (name in `badgeCounterExport`)
+  //    and the host runs it while the widget's page is closed, so the page
+  //    badge stays live; the host gives a counter a read-only context.
+  //    `usePageBadge(null)` now means "not known yet" and keeps the current
+  //    badge; `undefined` still clears it. Linter rules `badge-counter-export-missing`
+  //    (error) and `badge-counter-undeclared` (warning).
+  // 1.161.0: additive (sc-10930) — `Accordion` / `AccordionItem`, themed
+  //    collapsible sections drawn from the `card` and `list` scopes: single
+  //    or multiple open, controlled or uncontrolled, `aria-expanded` headers.
+  version: "1.161.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -5327,6 +5361,8 @@ const CONTRACT = deepFreeze({
   themeWidgetStyles: THEME_WIDGET_STYLES,
   widgetContextShape: WIDGET_CONTEXT_SHAPE,
   bundleExportContract: BUNDLE_EXPORT_CONTRACT,
+  // sc-10829 — the hook a `badgeCounter: true` entry exports by name.
+  badgeCounterExport: "useBadgeCount",
   bannedApis: BANNED_APIS,
   vettedImports: VETTED_IMPORTS,
   allowedBareImports: ALLOWED_BARE_IMPORTS,

package/dist/hooks.js

@@ -621,8 +621,10 @@ export function useFilePreview(file) {
   return { uri };
 }
 
-// A count the host can draw: a whole number, 0 for nothing to show.
+// A count the host can draw: a whole number, 0 for nothing to show, null
+// only when the widget explicitly says it does not know yet.
 function _badgeCount(count) {
+  if (count === null) return null;
   return typeof count === "number" && Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
 }
 
@@ -631,8 +633,9 @@ function _badgeCount(count) {
  * on, such as a chat's unread messages. Returns `{ supported }`. The host sums
  * every widget on the page and keeps the last count after the widget leaves
  * the screen, until it reports again; 0 (or anything not a positive number)
- * clears this widget's share. A host without page badges (the Builder canvas)
- * ignores it.
+ * clears this widget's share. sc-10829: an explicit null means "not known
+ * yet" and keeps the current badge; undefined still clears. A host without
+ * page badges (the Builder canvas) ignores it.
  */
 export function usePageBadge(count) {
   const ctx = useWidgetContextOrThrow("usePageBadge");
@@ -640,7 +643,7 @@ export function usePageBadge(count) {
   const setBadge = typeof nav.setBadge === "function" ? nav.setBadge : null;
   const value = _badgeCount(count);
   useEffect(() => {
-    if (setBadge) setBadge(value);
+    if (setBadge && value !== null) setBadge(value);
   }, [setBadge, value]);
   return { supported: Boolean(setBadge) };
 }

package/dist/index.d.ts

@@ -397,8 +397,23 @@ export interface WidgetManifest {
    * /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/, value ≤1 KB.
    */
   translations?: Record<string, { en: string } & Record<string, string>>;
+  /**
+   * Optional (sc-10829, default false). True when every platform entry also
+   * exports `useBadgeCount(props)` (a `BadgeCounterHook`), which the host runs
+   * while the widget's page is closed so its menu badge stays live.
+   */
+  badgeCounter?: boolean;
 }
 
+/**
+ * sc-10829 — the `useBadgeCount` export of a `badgeCounter: true` widget. Called
+ * with the instance's resolved props inside the widget's own context; returns
+ * the page badge count, or `null` while it is not known yet. It only reads (the
+ * host gives it read-only clients and no device, payment or AI access): no
+ * rendering, writes, navigation, events, toasts or page-chrome hooks.
+ */
+export type BadgeCounterHook = (props: Record<string, unknown>) => number | null;
+
 /** A React Native shadow style object — one level of `ThemeTokens.elevation`. */
 export interface ElevationLevel {
   shadowColor?: string;
@@ -1821,17 +1836,19 @@ export function useNavigation(): {
  */
 export function useRouteParams(): Record<string, unknown>;
 
-/**
- * sc-10268 — puts `count` on the menu entry or tab of the page this widget is
- * on. The host sums the page's widgets and keeps the last count after the
- * widget leaves the screen; 0 clears this widget's share.
- */
 /**
  * sc-10268 — `{ uri }` an `<Image>` can show for a picked file before it is
  * uploaded. Null for no file, or a host that cannot preview one.
  */
 export function useFilePreview(file: unknown): { uri: string | null };
 
+/**
+ * sc-10268 — puts `count` on the menu entry or tab of the page this widget is
+ * on. The host sums the page's widgets and keeps the last count after the
+ * widget leaves the screen; 0 or `undefined` clears this widget's share.
+ * sc-10829: an explicit `null` means the count is not known yet and keeps the
+ * current badge.
+ */
 export function usePageBadge(count: number | null | undefined): {
   supported: boolean;
 };
@@ -3424,6 +3441,52 @@ export const Tabs: (props: {
   testID?: string;
 }) => any;
 
+/**
+ * Themed collapsible sections. The surface comes from the theme's `card`
+ * scope and the headers and dividers from its `list` scope, so every
+ * collapsible section in the app matches. Each header announces whether its
+ * section is open, and a section's body mounts only while it is open.
+ *
+ * @example
+ *   <Accordion defaultValue="shipping">
+ *     <AccordionItem value="shipping" title="Shipping" subtitle="2-4 days">…</AccordionItem>
+ *     <AccordionItem value="returns" title="Returns">…</AccordionItem>
+ *   </Accordion>
+ */
+export const Accordion: (props: {
+  /** Several sections may be open at once; by default opening one closes the other. */
+  multiple?: boolean;
+  /** The open section key (an array of keys when `multiple`); makes it controlled. */
+  value?: string | string[] | null;
+  /** The initially open section(s) when uncontrolled. */
+  defaultValue?: string | string[] | null;
+  /** The open section(s) after a header press, in the same shape as `value`. */
+  onChange?: (next: string | string[] | null) => void;
+  children?: ReactNode;
+  /** Names the group of sections for assistive technology. */
+  accessibilityLabel?: string;
+  style?: any;
+  testID?: string;
+}) => any;
+
+/** One section of an `<Accordion>`; on its own it is an accordion of one. */
+export const AccordionItem: (props: {
+  /** The key `value` / `defaultValue` / `onChange` name it by; give one whenever you name sections. */
+  value?: string;
+  title?: ReactNode;
+  subtitle?: ReactNode;
+  /** Beside the header and outside its toggle, so a button here does its own thing. */
+  trailing?: ReactNode;
+  disabled?: boolean;
+  /** Rule under the section (default true); the surface edge hides the last one's. */
+  divider?: boolean;
+  children?: ReactNode;
+  accessibilityLabel?: string;
+  style?: any;
+  /** Also tags the header (`<testID>-header`) and open body (`<testID>-panel`). */
+  testID?: string;
+}) => any;
+
 export type TextRole = "display" | "title" | "subtitle" | "body" | "caption" | "overline";
 export const TEXT_ROLES: readonly TextRole[];
 export const TEXT_TRANSFORMS: readonly string[];
@@ -3851,6 +3914,8 @@ export interface AiWidgetContract {
     >
   >;
   readonly bundleExportContract: ReadonlyArray<ContractBundleShape>;
+  /** sc-10829 — the export name of a `badgeCounter: true` entry's hook. */
+  readonly badgeCounterExport: "useBadgeCount";
   readonly bannedApis: ReadonlyArray<ContractBannedApi>;
   readonly allowedBareImports: ReadonlyArray<string>;
   /** Bare specifiers the web host provides by exact name; a widget bundle never inlines them. */

package/dist/index.js

@@ -257,6 +257,8 @@ export {
 } from "./button-style.js";
 // The themed text-entry field; follows the theme's `muted` scope.
 export { TextField } from "./text-field.js";
+// Themed collapsible sections, drawn from the `card` and `list` scopes.
+export { Accordion, AccordionItem } from "./accordion.js";
 // A themed tab strip; follows the theme's `tabs` scope.
 export { Tabs } from "./tabs.js";
 // The semantic text tiers, shared with the built-in widgets.

package/dist/index.native.js

@@ -250,6 +250,8 @@ export {
 } from "./button-style.js";
 // The themed text-entry field; follows the theme's `muted` scope.
 export { TextField } from "./text-field.native.js";
+// Themed collapsible sections, drawn from the `card` and `list` scopes.
+export { Accordion, AccordionItem } from "./accordion.native.js";
 // A themed tab strip; follows the theme's `tabs` scope.
 export { Tabs } from "./tabs.native.js";
 // The semantic text tiers, shared with the built-in widgets.

package/dist/linter.cjs

@@ -1992,6 +1992,54 @@ function lintEditability(manifest, files) {
   return { ok: true, findings };
 }
 
+// sc-10829 — `manifest.badgeCounter` promises the host a hook it can run
+// while the page is closed; each shipped entry must export it by name.
+function _exportedNameLine(code, name) {
+  const declared = new RegExp(
+    `\\bexport\\s+(?:(?:async\\s+)?function\\b\\s*\\*?\\s*|(?:const|let|var)\\s+)${name}\\b`,
+  );
+  const hit = declared.exec(code);
+  if (hit) return code.slice(0, hit.index).split("\n").length;
+  for (const clause of code.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
+    const names = clause[1].split(",").map((part) => part.trim().split(/\s+as\s+/).pop().trim());
+    if (names.includes(name)) return code.slice(0, clause.index).split("\n").length;
+  }
+  return 0;
+}
+
+function _badgeCounterRules(source, manifest) {
+  if (!manifest || typeof manifest !== "object") return [];
+  const name = CONTRACT.badgeCounterExport;
+  const line = _exportedNameLine(_stripNonCode(source), name);
+  if (manifest.badgeCounter === true && line === 0) {
+    return [
+      {
+        rule: "badge-counter-export-missing",
+        severity: "error",
+        label:
+          `manifest.badgeCounter is true but this entry does not export ${name}(props). ` +
+          "Export the hook from every platform entry, or drop badgeCounter.",
+        line: 0,
+        snippet: "",
+      },
+    ];
+  }
+  if (manifest.badgeCounter !== true && line > 0) {
+    return [
+      {
+        rule: "badge-counter-undeclared",
+        severity: "warning",
+        label:
+          `This entry exports ${name} but manifest.badgeCounter is not true, so the host never runs it. ` +
+          "Declare badgeCounter: true, or remove the export.",
+        line,
+        snippet: source.split(/\r?\n/)[line - 1].trim().slice(0, 200),
+      },
+    ];
+  }
+  return [];
+}
+
 function lintSource(source, options) {
   if (typeof source !== "string") {
     return {
@@ -2070,6 +2118,7 @@ function lintSource(source, options) {
     })),
   );
   findings.push(..._manifestActionRules(options && options.manifest));
+  findings.push(..._badgeCounterRules(source, options && options.manifest));
   const hasErrors = findings.some((f) => f.severity !== "warning");
   return { ok: !hasErrors, findings };
 }

package/dist/linter.js

@@ -2055,6 +2055,54 @@ export function lintEditability(manifest, files) {
   return { ok: true, findings };
 }
 
+// sc-10829 — `manifest.badgeCounter` promises the host a hook it can run
+// while the page is closed; each shipped entry must export it by name.
+function _exportedNameLine(code, name) {
+  const declared = new RegExp(
+    `\\bexport\\s+(?:(?:async\\s+)?function\\b\\s*\\*?\\s*|(?:const|let|var)\\s+)${name}\\b`,
+  );
+  const hit = declared.exec(code);
+  if (hit) return code.slice(0, hit.index).split("\n").length;
+  for (const clause of code.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
+    const names = clause[1].split(",").map((part) => part.trim().split(/\s+as\s+/).pop().trim());
+    if (names.includes(name)) return code.slice(0, clause.index).split("\n").length;
+  }
+  return 0;
+}
+
+function _badgeCounterRules(source, manifest) {
+  if (!manifest || typeof manifest !== "object") return [];
+  const name = CONTRACT.badgeCounterExport;
+  const line = _exportedNameLine(_stripNonCode(source), name);
+  if (manifest.badgeCounter === true && line === 0) {
+    return [
+      {
+        rule: "badge-counter-export-missing",
+        severity: "error",
+        label:
+          `manifest.badgeCounter is true but this entry does not export ${name}(props). ` +
+          "Export the hook from every platform entry, or drop badgeCounter.",
+        line: 0,
+        snippet: "",
+      },
+    ];
+  }
+  if (manifest.badgeCounter !== true && line > 0) {
+    return [
+      {
+        rule: "badge-counter-undeclared",
+        severity: "warning",
+        label:
+          `This entry exports ${name} but manifest.badgeCounter is not true, so the host never runs it. ` +
+          "Declare badgeCounter: true, or remove the export.",
+        line,
+        snippet: source.split(/\r?\n/)[line - 1].trim().slice(0, 200),
+      },
+    ];
+  }
+  return [];
+}
+
 export function lintSource(source, options) {
   if (typeof source !== "string") {
     return {
@@ -2142,6 +2190,7 @@ export function lintSource(source, options) {
   );
   // REQ-WIDGET-ACTION — structural validation of manifest-declared actions.
   findings.push(..._manifestActionRules(options && options.manifest));
+  findings.push(..._badgeCounterRules(source, options && options.manifest));
   const hasErrors = findings.some((f) => f.severity !== "warning");
   return { ok: !hasErrors, findings };
 }

package/dist/manifest.cjs

@@ -325,6 +325,12 @@ function validateManifest(m) {
     validateManifestTranslations(manifest.translations, manifest.id, errors);
   }
 
+  pushIf(
+    errors,
+    manifest.badgeCounter === undefined || typeof manifest.badgeCounter === "boolean",
+    "manifest.badgeCounter must be a boolean when present",
+  );
+
   return errors.length === 0 ? { ok: true } : { ok: false, errors };
 }
 

package/dist/manifest.js

@@ -371,6 +371,12 @@ function validateManifest(m) {
     validateManifestTranslations(manifest.translations, manifest.id, errors);
   }
 
+  pushIf(
+    errors,
+    manifest.badgeCounter === undefined || typeof manifest.badgeCounter === "boolean",
+    "manifest.badgeCounter must be a boolean when present",
+  );
+
   return errors.length === 0 ? { ok: true } : { ok: false, errors };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colixsystems/widget-sdk",
-  "version": "0.200.0",
+  "version": "0.202.0",
   "description": "Common widget interface for AppStudio. Implements WidgetManifest, WidgetContext, property schema, and helper hooks.",
   "homepage": "https://github.com/Colix-AB/AppStudio",
   "type": "module",

package/src/contract.js

@@ -1065,7 +1065,10 @@ const HOOKS = [
     description:
       "Puts count on the menu entry or tab of the page this widget is on (a chat's unread messages, open tasks). " +
       "The host sums every widget on the page and keeps the last count after the widget leaves the screen, until it " +
-      "reports again; 0, or anything not a positive number, clears this widget's share. Returns { supported }: false " +
+      "reports again; 0, undefined, or any other value that is not a positive number, clears this widget's share. " +
+      "An explicit null means the count is not known yet and keeps the current badge (pass null until the first load " +
+      "settles, so the badge never flashes to 0). manifest.badgeCounter keeps the badge live while the page is closed; " +
+      "see that field for who may declare it. Returns { supported }: false " +
       "on a host without page badges (the Builder canvas), where it does nothing. Call it at render with the current " +
       "count, never in a loop. Backed by ctx.navigation.setBadge. Identical on web (Player) and the Expo export.",
     returnShape: {
@@ -1447,7 +1450,7 @@ const HOOKS = [
       message: "string | null",
       signerName: "string | null",
       signedAt: "string | null",
-      verdict: "{ valid, checks, content_status, ... } | null",
+      verdict: "{ valid, checks, content_status, signed_by_others_since, seal, ... } | null",
       loading: "boolean",
       error: "PermissionError | null  // { code, message, retryable }",
       initiate: "() => Promise<{ signature_id, qr, auto_start_token, status }>",
@@ -2801,6 +2804,20 @@ const PRIMITIVES = [
     rnComponent: null,
     docsUrl: null,
   },
+  {
+    name: "Accordion",
+    description:
+      'Themed collapsible sections. `<Accordion defaultValue="shipping"><AccordionItem value="shipping" title="Shipping" subtitle="2-4 days">…</AccordionItem><AccordionItem value="returns" title="Returns">…</AccordionItem></Accordion>`. THE way to build a section that expands and collapses (an FAQ, a settings group, a record\'s details, a group whose members show on demand): the surface takes the app\'s card look (Theme Settings > Cards: background, border, corner radius) and the headers and dividers its list look (Theme Settings > Lists: row padding, row height, divider), so every collapsible section in the app matches. Each header has a chevron, a 44px touch target, works from the keyboard and tells assistive technology whether its section is open, so never hand-roll a collapsible from `Pressable` + a chevron + a `useState`. By default one section is open at a time and pressing the open one closes it; `multiple` lets several stay open. Props: `multiple`, `value` (the open key, or an array of keys when `multiple`; makes it controlled), `defaultValue` (the same shape, uncontrolled), `onChange(next)` (the open key(s) after a press, in the same shape), `accessibilityLabel`, `style`, `testID`. Its children are `<AccordionItem>`s.',
+    rnComponent: null,
+    docsUrl: null,
+  },
+  {
+    name: "AccordionItem",
+    description:
+      'One section of an `<Accordion>`. `<AccordionItem value={group.id} title={group.name} subtitle={`${group.count} members`} trailing={<Button title="Delete" variant="danger" onPress={remove} />}>…</AccordionItem>`. Props: `value` (the key `value` / `defaultValue` / `onChange` name it by — give one whenever you name sections; an item may sit inside your own component or a fragment), `title`, `subtitle` (the subtitle / caption text tiers), `trailing` (a node beside the header and OUTSIDE its toggle, so a button there runs its own action without opening the section), `disabled`, `divider` (default true; the surface edge hides the rule under the last section), `children` (the body: it mounts only while the section is open, so fetch its data inside it; an `<AccordionItem>` placed in a body is its own section, never part of the outer accordion), `accessibilityLabel` (defaults to the string `title` and `subtitle`), `style`, `testID` (also tags the header `<testID>-header` and the open body `<testID>-panel`). On its own, outside an `<Accordion>`, it is an accordion of one.',
+    rnComponent: null,
+    docsUrl: null,
+  },
   {
     name: "Tabs",
     description:
@@ -3043,6 +3060,13 @@ const MANIFEST_SCHEMA = {
       "Optional (default false). TRUE when the widget draws a strip of live figures (counts, totals, averages) about the records it shows, or is itself a strip of figures. The AppStudio app-builder reads this when it places an already-installed widget: it counts the widget as the page's figures, so it does not plan a second strip of figures beside it. Set it to match what the component actually renders; leave it false (or omit) when the widget draws no figures.",
     default: false,
   },
+  badgeCounter: {
+    type: "boolean",
+    required: false,
+    description:
+      "Optional (default false). TRUE when every platform entry also exports useBadgeCount(props): a hook returning the count the widget puts on its page's menu entry with usePageBadge, so the app keeps that badge live while the page is closed. The host runs counters for installed marketplace widgets (the workspace's own published widgets included); the platform's built-in widgets declare none. It calls the hook with the instance's resolved props, inside the widget's own context; the hook returns a whole number, or null while the count is not known yet. It only reads, and the host enforces that: the counter's datastore and directory expose only their read methods (plus realtime subscriptions) and notification mutes only get/list, while writes, typing signals, payments, notifications.send, files, assets, AI agents, translation, link previews, device capabilities, identification and account actions all answer as unavailable. It also renders nothing, navigates nowhere, emits no events or toasts, marks nothing read, and calls none of usePageBadge, useScreenTitle, useSectionEmpty or useWidgetRoute's setter. The linter refuses a declared counter whose entry has no useBadgeCount export. The AppStudio widget agent leaves this unset: a generated widget never declares a badge counter.",
+    default: false,
+  },
   events: {
     type: "object[]",
     required: true,
@@ -5301,7 +5325,17 @@ const CONTRACT = deepFreeze({
   //    flat `assets/` directory (`bundledAssets`, within `packageMaxBytes`).
   //    New `useBundledAsset(fileName)` resolves one through the new
   //    `widget.assets` map; linter rule `bundled-asset-missing` (error).
-  version: "1.159.0",
+  // 1.160.0: additive (sc-10829) — optional manifest field `badgeCounter`:
+  //    the entry exports `useBadgeCount(props)` (name in `badgeCounterExport`)
+  //    and the host runs it while the widget's page is closed, so the page
+  //    badge stays live; the host gives a counter a read-only context.
+  //    `usePageBadge(null)` now means "not known yet" and keeps the current
+  //    badge; `undefined` still clears it. Linter rules `badge-counter-export-missing`
+  //    (error) and `badge-counter-undeclared` (warning).
+  // 1.161.0: additive (sc-10930) — `Accordion` / `AccordionItem`, themed
+  //    collapsible sections drawn from the `card` and `list` scopes: single
+  //    or multiple open, controlled or uncontrolled, `aria-expanded` headers.
+  version: "1.161.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -5327,6 +5361,8 @@ const CONTRACT = deepFreeze({
   themeWidgetStyles: THEME_WIDGET_STYLES,
   widgetContextShape: WIDGET_CONTEXT_SHAPE,
   bundleExportContract: BUNDLE_EXPORT_CONTRACT,
+  // sc-10829 — the hook a `badgeCounter: true` entry exports by name.
+  badgeCounterExport: "useBadgeCount",
   bannedApis: BANNED_APIS,
   vettedImports: VETTED_IMPORTS,
   allowedBareImports: ALLOWED_BARE_IMPORTS,