@colixsystems/widget-sdk 0.89.0 → 0.91.0

package/README.md

@@ -35,6 +35,7 @@ The data layer lives in **four separate domain-client packages**, each instantia
 | **CORE** | `useClipboard()` | `{ copy, paste, hasContent }` | platform clipboard (web `navigator.clipboard` / native `expo-clipboard`); rejects with `ClipboardError` — no scope |
 | **CORE** | `useToast()` | `{ showToast }` | `ctx.toast.showToast` — wired by the Player and the Expo export; an authoring preview omits it and the call is a no-op — no scope |
 | **CORE** | `useGeolocation(options?)` | `{ latitude, longitude, accuracy, loading, error, getCurrentPosition }` | `ctx.device.geolocation` — no scope. Capture is IMPERATIVE: call `getCurrentPosition()` from a user gesture (a tap), never on mount. Resolves to `{ latitude, longitude, accuracy }`; rejects with `GeolocationError` (`.code` in `PERMISSION_DENIED \| UNAVAILABLE \| TIMEOUT \| UNSUPPORTED \| INTERNAL`). Identical on web (`navigator.geolocation`) and the Expo export (`expo-location`). |
+| **CORE** | `useSpeechToText(options?)` | `{ transcript, partial, listening, supported, error, start, stop, abort, reset }` | `ctx.device.speech` — no scope. Dictation with the device's **on-device** recogniser: no audio is uploaded and no AI credit is spent. Capture is IMPERATIVE: call `start()` from a user gesture (a tap), never on mount. `transcript` accumulates finalised speech, `partial` holds the uncommitted guess (needs `options.interimResults`); `stop()` keeps it, `abort()` discards it. Rejects with `SpeechToTextError` (`.code` in `PERMISSION_DENIED \| NO_SPEECH \| LANGUAGE_UNSUPPORTED \| NETWORK \| ABORTED \| UNSUPPORTED \| INTERNAL`). **Gate your mic button on `supported`** — Firefox ships no `SpeechRecognition`. Identical on web (`SpeechRecognition`) and the Expo export (`expo-speech-recognition`). |
 | **CORE** | `useI18n()` | `{ t, locale }` | `ctx.i18n` — no scope. `t(key)` resolves the widget-namespaced key (`widget.<id>.<key>`, declared in `manifest.translations`) first, then a **predefined shared key** (`shared.<key>`) when `key` is one of the standard strings (`submit`, `cancel`, `save`, `loading`, …), then the raw key. Use a shared key for an identical default string so it translates once and any per-instance `widget.<id>.<key>` override still wins. |
 | **CORE** | `useTranslate()` | `{ translate, translating, error, language, available }` | `ctx.i18n.translate` — no scope. Machine-translates **user-generated content** (record text, file names, API payloads) into the app user's language; `useI18n().t()` is still the answer for your own copy. `translate(str)` → `Promise<string>`, `translate(str[])` → `Promise<string[]>` in ONE request. Target defaults to the app user's language. Cached per session, per pod, and durably per workspace, so repeat text is free. Limits: 50 segments / 5 000 chars each / 20 000 total. Rejects with `TranslateError`; `available` is false where the host cannot translate. |
 | **DATASTORE** (`ctx.datastore`) | `useDatastoreQuery(table, options?)` | `{ data, loading, error, refetch }` | `records(table).list` (unwraps `{ data, meta }` to `data: []`) — `datastore.read:*` |
@@ -61,7 +62,19 @@ See the design reference for the full architecture: [`docs/architecture/widget-m
 
 ## Status
 
-`v0.89.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.91.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.91.0 (contract 1.64.0)
+
+**New `useSpeechToText()` hook — dictate into text with the device's on-device recogniser.** A new CORE hook reading a new `speech` capability on the existing `ctx.device` slice. Returns `{ transcript, partial, listening, supported, error, start, stop, abort, reset }`. Capture is **imperative** — call `start()` from a user gesture (a `Pressable.onPress`); the browser and the mobile OS gate the microphone prompt on a gesture, so it NEVER listens on mount. `transcript` accumulates finalised speech across utterances; `partial` holds the guess the recogniser has not committed yet (empty unless `options.interimResults`). `stop()` finalises and keeps what was heard, `abort()` discards the current utterance, `reset()` clears both. `options` (`{ lang, continuous, interimResults }`) pass through to the host. Rejections surface as a structured `SpeechToTextError` (new named export) with a stable `.code` (`PERMISSION_DENIED` / `NO_SPEECH` / `LANGUAGE_UNSUPPORTED` / `NETWORK` / `ABORTED` / `UNSUPPORTED` / `INTERNAL`). It needs **no manifest scope** and **no `requestedScopes` entry**.
+
+Recognition runs **on device**: no audio is uploaded, nothing reaches our servers, and no AI credit is spent — so the hook is available to every workspace regardless of its AI data-residency policy. The web Player brokers it via the browser's `SpeechRecognition`; the Expo export via `expo-speech-recognition`, whose config plugin declares the microphone and speech permissions the runtime needs. Both hosts emit the same Web Speech error vocabulary, so one mapping serves both.
+
+**Always gate your mic affordance on `supported`.** Firefox ships no `SpeechRecognition` at all, so `supported` is `false` there and `start()` rejects with `UNSUPPORTED` — render the plain text field instead of a dead button. The `speech` capability is optional and forwarded independently of `geolocation`, so a host that brokers one still brokers the other.
+
+Additive — one new hook, one new optional device capability, one new error class; no existing export changed signature.
+
+`v0.90.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.89.0 (contract unchanged)
 
@@ -172,6 +185,10 @@ See the design reference for the full architecture: [`docs/architecture/widget-m
 - **The colour maths ignores alpha, on purpose.** `hexChannels` reads the R/G/B pair and skips any alpha, so contrast, readable text and the derived accent tints reason about the opaque colour. None of them can composite without knowing the backdrop, which a token table does not have — so transparency lives in the VALUE your widget renders, not in the decision about whether that colour reads as light or dark.
 - **`CONTRACT.version` → `1.61.0`** (additive: `themeTokens.spacingScale` + `widgetStyles` and their bounds, `themeComponents.card.universalFields`, and the `normaliseWidgetStyles` / `deriveSurfaceTokens` host exports). No author-facing export changed signature, and a theme that sets none of it resolves exactly as before.
 
+### What's new in 0.90.0 (contract 1.63.0)
+
+**A manifest action declares `triggerTypes` — a set — and the script learns which one fired (sc-4915).** An action could carry exactly one trigger, so a widget that needed the same work done on create *and* on delete had to ship the script twice: two `actions` entries, two operator bindings, two run histories, and the usual drift between the copies. `triggerTypes` replaces `triggerType`: a non-empty array of unique values from `schedule`, `record_created`, `record_updated`, `record_deleted`, freely combined (`scheduleCron` is required iff the array contains `schedule`). The pre-0.90.0 scalar `triggerType` is still read and normalised into the array, so a widget already published against it keeps validating and nothing needs republishing. What makes the combination useful is the other half: the script's `triggerType` global now names the trigger that **actually fired this run** — including `"manual"` (an operator's Run now) and `"app"` (a button press) — instead of echoing the row's configuration, so one script can branch on whether its record was created or deleted. `CONTRACT.version` → `1.63.0`. Additive for every existing manifest.
+
 ### 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.
@@ -619,7 +636,7 @@ Two additive features land in this version.
 
 **A widget may declare server-side actions in its manifest.**
 
-- **`WidgetManifest.actions` is now part of the public contract.** An optional array; each entry is `{ key, name, description?, triggerType, scheduleCron?, timeoutMs?, scriptSource }`. `triggerType` is one of `schedule`, `record_created`, `record_updated`, `record_deleted`; `scheduleCron` is required when `triggerType === "schedule"`. The `scriptSource` (≤ 200 KiB) runs in the **shared isolated-vm action runner** — against `datastore` / `fetch` / `connectors` / `console` / `record` / `tenantId` (the runner surface, **not** the React/SDK widget surface, so SDK imports and hooks are unavailable there and the component linter does not scan it). `connectors.call(slug, { method, path, query, body, headers })` resolves a tenant-configured REST connector by slug and returns `{ status, headers, body }` (auth + SSRF handled by the platform; an unknown slug / SSRF / timeout throws a catchable Error). Actions never run in the rendered app, so they have **no effect on Player ↔ export parity**.
+- **`WidgetManifest.actions` is now part of the public contract.** An optional array; each entry is `{ key, name, description?, triggerTypes, scheduleCron?, timeoutMs?, scriptSource }`. `triggerTypes` is a non-empty array of unique values from `schedule`, `record_created`, `record_updated`, `record_deleted` — combine them so one script serves several events; `scheduleCron` is required when it contains `schedule`. The `scriptSource` (≤ 200 KiB) runs in the **shared isolated-vm action runner** — against `datastore` / `fetch` / `connectors` / `console` / `record` / `tenantId` (the runner surface, **not** the React/SDK widget surface, so SDK imports and hooks are unavailable there and the component linter does not scan it). `connectors.call(slug, { method, path, query, body, headers })` resolves a tenant-configured REST connector by slug and returns `{ status, headers, body }` (auth + SSRF handled by the platform; an unknown slug / SSRF / timeout throws a catchable Error). Actions never run in the rendered app, so they have **no effect on Player ↔ export parity**.
 - **Operators enable actions per tenant** from the Properties Panel. An enabled action materialises a tenant `Action` row **DISABLED** until the operator binds an integration API key (and, for `record_*` triggers, a target table) in the Actions admin page — those bindings are tenant-local, so `triggerTableId` / `apiKeyId` must **not** appear in the manifest (the validator and linter reject them).
 - **New contract fields** `CONTRACT.actionTriggerTypes`, `CONTRACT.actionScriptGlobals`, `CONTRACT.actionScriptMaxBytes` expose the grammar so the Developer page, the AI agent prompt, and `validateManifest` derive it from one source. `validateManifest` now structurally validates `actions`; the marketplace linter rejects malformed / oversized declarations.
 - **New manifest category `ADMINISTRATION`** for app-administration widgets such as User Management. Added to `CONTRACT.manifestCategories`, `validateManifest`, the `WidgetCategory` type, the marketplace category list, and the master-DB `WidgetCategory` enum.

package/dist/contract.cjs

@@ -1194,6 +1194,35 @@ const HOOKS = [
     requiredContextSlice: [],
     scopes: null,
   },
+  // Host-brokered on-device speech recognition. Optional slice; the hook
+  // reports supported:false rather than throwing at render.
+  {
+    name: "useSpeechToText",
+    signature: "useSpeechToText(options?)",
+    description:
+      "Dictate into text with the device's ON-DEVICE speech recogniser. Returns { transcript, partial, listening, supported, " +
+      "error, start, stop, abort, reset }. Capture is IMPERATIVE — call start() from a user gesture (a tap on a mic button); " +
+      "the browser and the mobile OS gate the microphone prompt on a gesture, so it NEVER listens on mount. `transcript` " +
+      "accumulates finalised speech; `partial` holds the uncommitted guess (empty unless options.interimResults). stop() " +
+      "finalises and keeps what was heard, abort() discards it, reset() clears both. Recognition runs ON DEVICE — no audio is " +
+      "uploaded and no AI credit is spent. start() rejects with a SpeechToTextError whose .code is one of PERMISSION_DENIED | " +
+      "NO_SPEECH | LANGUAGE_UNSUPPORTED | NETWORK | ABORTED | UNSUPPORTED | INTERNAL. options: { lang, continuous, " +
+      "interimResults }. Check `supported` before rendering a mic button — a browser without SpeechRecognition (Firefox) " +
+      "reports false. Identical on web (SpeechRecognition) and the Expo export (expo-speech-recognition).",
+    returnShape: {
+      transcript: "string  // finalised speech, accumulated",
+      partial: "string  // uncommitted guess; '' unless interimResults",
+      listening: "boolean",
+      supported: "boolean  // false when the host brokers no recogniser",
+      error: "SpeechToTextError | null",
+      start: "() => Promise<void>  // rejects with SpeechToTextError",
+      stop: "() => Promise<void>  // finalise, keep the transcript",
+      abort: "() => void  // cancel, discard the utterance",
+      reset: "() => void  // clear transcript + partial + error",
+    },
+    requiredContextSlice: [],
+    scopes: null,
+  },
 ];
 
 // REQ-WSDK-RN-WEB: the SDK exposes the React Native primitive API
@@ -1373,6 +1402,34 @@ const ACTION_SCRIPT_GLOBALS = [
 // Mirrors action.service.js SCRIPT_MAX_BYTES.
 const ACTION_SCRIPT_MAX_BYTES = 200 * 1024;
 
+/**
+ * sc-4915 — the trigger set a manifest action declares, canonically ordered.
+ *
+ * `triggerTypes` is the current shape; the pre-sc-4915 scalar `triggerType` is
+ * still read so a widget published before the change keeps validating. Returns
+ * null when the declaration is empty, holds an unknown value, or repeats one —
+ * every caller reports that as a manifest error. ONE reader, so the SDK
+ * validator, the CLI linter and the backend cannot disagree about what a
+ * manifest declared.
+ */
+function normaliseActionTriggerTypes(action) {
+  const a = action !== null && typeof action === "object" ? action : {};
+  const raw = Array.isArray(a.triggerTypes)
+    ? a.triggerTypes
+    : a.triggerTypes === undefined && a.triggerType !== undefined
+      ? [a.triggerType]
+      : null;
+  if (raw === null || raw.length === 0) return null;
+  const seen = new Set();
+  for (const t of raw) {
+    if (typeof t !== "string" || !ACTION_TRIGGER_TYPES.includes(t)) return null;
+    if (seen.has(t)) return null;
+    seen.add(t);
+  }
+  return ACTION_TRIGGER_TYPES.filter((t) => seen.has(t));
+}
+
+
 // Reverse-DNS-ish manifest id, e.g. "com.acme.charts.barchart". Two or
 // more labels, lowercase alnum + hyphen, label starts with a letter. The
 // analyzer + the SDK validator both read this from the contract so a
@@ -1501,9 +1558,9 @@ const MANIFEST_SCHEMA = {
     type: "object[]",
     required: false,
     description:
-      "Optional. Server-side actions the widget declares. Each runs in the shared isolated-vm action runner (cron- or record-triggered) — NEVER in the rendered app. Operators enable them per tenant from the Properties Panel; the action materialises DISABLED until they bind an integration API key (and, for record_* triggers, a target table) in the Actions admin page. Each entry: { key (stable, unique within the manifest), name, description?, triggerType (one of " +
+      "Optional. Server-side actions the widget declares. Each runs in the shared isolated-vm action runner (cron- or record-triggered) — NEVER in the rendered app. Operators enable them per tenant from the Properties Panel; the action materialises DISABLED until they bind an integration API key (and, for record_* triggers, a target table) in the Actions admin page. Each entry: { key (stable, unique within the manifest), name, description?, triggerTypes (a non-empty array of unique values from " +
       ACTION_TRIGGER_TYPES.join(", ") +
-      "), scheduleCron? (required iff triggerType=='schedule'; node-cron syntax), timeoutMs? (100–300000), scriptSource (≤200 KiB; runs against " +
+      "; combine them so one script serves several events — the script's `triggerType` global names the event that actually fired), scheduleCron? (required iff triggerTypes contains 'schedule'; node-cron syntax), timeoutMs? (100–300000), scriptSource (≤200 KiB; runs against " +
       ACTION_SCRIPT_GLOBALS.join(", ") +
       " — NOT the React surface, so SDK imports/hooks are unavailable) }. Do NOT include triggerTableId or apiKeyId — those are tenant-local and bound after install.",
     default: [],
@@ -1741,11 +1798,15 @@ const WIDGET_CONTEXT_SHAPE = {
   device: {
     description:
       "Optional host-brokered device capabilities. " +
-      "{ geolocation: { getCurrentPosition(options?) -> Promise<{ latitude, longitude, accuracy }> } }. " +
-      "Backs useGeolocation(). The web Player brokers it via navigator.geolocation; the Expo export via expo-location. " +
-      "getCurrentPosition rejects with a GeolocationError (.code PERMISSION_DENIED | UNAVAILABLE | TIMEOUT | UNSUPPORTED | INTERNAL).",
+      "{ geolocation: { getCurrentPosition(options?) -> Promise<{ latitude, longitude, accuracy }> }, " +
+      "speech: { isSupported() -> boolean, start(options, { onResult, onError, onEnd }) -> Promise<{ stop(), abort() }> } }. " +
+      "Backs useGeolocation() and useSpeechToText(). The web Player brokers them via navigator.geolocation and " +
+      "window.SpeechRecognition; the Expo export via expo-location and expo-speech-recognition. " +
+      "getCurrentPosition rejects with a GeolocationError (.code PERMISSION_DENIED | UNAVAILABLE | TIMEOUT | UNSUPPORTED | INTERNAL). " +
+      "speech.start streams { transcript, isFinal } to onResult and runs ON DEVICE — it uploads no audio and spends no AI credit; " +
+      "its onError carries the Web Speech error vocabulary (not-allowed | no-speech | language-not-supported | network | aborted).",
     required: false,
-    fields: { geolocation: "object" },
+    fields: { geolocation: "object", speech: "object" },
   },
 };
 
@@ -2787,7 +2848,14 @@ const CONTRACT = deepFreeze({
   //    Naming one widget is strictly more specific than restyling a scope, and
   //    the Properties Panel stays the final word. Additive throughout: a theme
   //    that sets none of it resolves exactly as before.
-  version: "1.62.0",
+  // 1.63.0: additive (sc-4915) — a manifest action declares `triggerTypes`, a
+  //    non-empty ARRAY, so one script can serve a create, an update and a
+  //    delete instead of being copied into three actions. The pre-sc-4915
+  //    scalar `triggerType` is still read and normalised, so an already
+  //    published widget keeps validating. The script's `triggerType` global
+  //    now names the trigger that actually FIRED the run ('manual' and 'app'
+  //    included), which is what makes a multi-trigger script able to branch.
+  version: "1.64.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -3073,6 +3141,7 @@ module.exports = {
   CONTRACT,
   clampSpacingScale,
   scaleSpacing,
+  normaliseActionTriggerTypes,
   isHookAllowed,
   requiredContextKeys,
   isHexColor,

package/dist/contract.js

@@ -1194,6 +1194,35 @@ const HOOKS = [
     requiredContextSlice: [],
     scopes: null,
   },
+  // Host-brokered on-device speech recognition. Optional slice; the hook
+  // reports supported:false rather than throwing at render.
+  {
+    name: "useSpeechToText",
+    signature: "useSpeechToText(options?)",
+    description:
+      "Dictate into text with the device's ON-DEVICE speech recogniser. Returns { transcript, partial, listening, supported, " +
+      "error, start, stop, abort, reset }. Capture is IMPERATIVE — call start() from a user gesture (a tap on a mic button); " +
+      "the browser and the mobile OS gate the microphone prompt on a gesture, so it NEVER listens on mount. `transcript` " +
+      "accumulates finalised speech; `partial` holds the uncommitted guess (empty unless options.interimResults). stop() " +
+      "finalises and keeps what was heard, abort() discards it, reset() clears both. Recognition runs ON DEVICE — no audio is " +
+      "uploaded and no AI credit is spent. start() rejects with a SpeechToTextError whose .code is one of PERMISSION_DENIED | " +
+      "NO_SPEECH | LANGUAGE_UNSUPPORTED | NETWORK | ABORTED | UNSUPPORTED | INTERNAL. options: { lang, continuous, " +
+      "interimResults }. Check `supported` before rendering a mic button — a browser without SpeechRecognition (Firefox) " +
+      "reports false. Identical on web (SpeechRecognition) and the Expo export (expo-speech-recognition).",
+    returnShape: {
+      transcript: "string  // finalised speech, accumulated",
+      partial: "string  // uncommitted guess; '' unless interimResults",
+      listening: "boolean",
+      supported: "boolean  // false when the host brokers no recogniser",
+      error: "SpeechToTextError | null",
+      start: "() => Promise<void>  // rejects with SpeechToTextError",
+      stop: "() => Promise<void>  // finalise, keep the transcript",
+      abort: "() => void  // cancel, discard the utterance",
+      reset: "() => void  // clear transcript + partial + error",
+    },
+    requiredContextSlice: [],
+    scopes: null,
+  },
 ];
 
 // REQ-WSDK-RN-WEB: the SDK exposes the React Native primitive API
@@ -1373,6 +1402,34 @@ const ACTION_SCRIPT_GLOBALS = [
 // Mirrors action.service.js SCRIPT_MAX_BYTES.
 const ACTION_SCRIPT_MAX_BYTES = 200 * 1024;
 
+/**
+ * sc-4915 — the trigger set a manifest action declares, canonically ordered.
+ *
+ * `triggerTypes` is the current shape; the pre-sc-4915 scalar `triggerType` is
+ * still read so a widget published before the change keeps validating. Returns
+ * null when the declaration is empty, holds an unknown value, or repeats one —
+ * every caller reports that as a manifest error. ONE reader, so the SDK
+ * validator, the CLI linter and the backend cannot disagree about what a
+ * manifest declared.
+ */
+function normaliseActionTriggerTypes(action) {
+  const a = action !== null && typeof action === "object" ? action : {};
+  const raw = Array.isArray(a.triggerTypes)
+    ? a.triggerTypes
+    : a.triggerTypes === undefined && a.triggerType !== undefined
+      ? [a.triggerType]
+      : null;
+  if (raw === null || raw.length === 0) return null;
+  const seen = new Set();
+  for (const t of raw) {
+    if (typeof t !== "string" || !ACTION_TRIGGER_TYPES.includes(t)) return null;
+    if (seen.has(t)) return null;
+    seen.add(t);
+  }
+  return ACTION_TRIGGER_TYPES.filter((t) => seen.has(t));
+}
+
+
 // Reverse-DNS-ish manifest id, e.g. "com.acme.charts.barchart". Two or
 // more labels, lowercase alnum + hyphen, label starts with a letter. The
 // analyzer + the SDK validator both read this from the contract so a
@@ -1501,9 +1558,9 @@ const MANIFEST_SCHEMA = {
     type: "object[]",
     required: false,
     description:
-      "Optional. Server-side actions the widget declares. Each runs in the shared isolated-vm action runner (cron- or record-triggered) — NEVER in the rendered app. Operators enable them per tenant from the Properties Panel; the action materialises DISABLED until they bind an integration API key (and, for record_* triggers, a target table) in the Actions admin page. Each entry: { key (stable, unique within the manifest), name, description?, triggerType (one of " +
+      "Optional. Server-side actions the widget declares. Each runs in the shared isolated-vm action runner (cron- or record-triggered) — NEVER in the rendered app. Operators enable them per tenant from the Properties Panel; the action materialises DISABLED until they bind an integration API key (and, for record_* triggers, a target table) in the Actions admin page. Each entry: { key (stable, unique within the manifest), name, description?, triggerTypes (a non-empty array of unique values from " +
       ACTION_TRIGGER_TYPES.join(", ") +
-      "), scheduleCron? (required iff triggerType=='schedule'; node-cron syntax), timeoutMs? (100–300000), scriptSource (≤200 KiB; runs against " +
+      "; combine them so one script serves several events — the script's `triggerType` global names the event that actually fired), scheduleCron? (required iff triggerTypes contains 'schedule'; node-cron syntax), timeoutMs? (100–300000), scriptSource (≤200 KiB; runs against " +
       ACTION_SCRIPT_GLOBALS.join(", ") +
       " — NOT the React surface, so SDK imports/hooks are unavailable) }. Do NOT include triggerTableId or apiKeyId — those are tenant-local and bound after install.",
     default: [],
@@ -1741,11 +1798,15 @@ const WIDGET_CONTEXT_SHAPE = {
   device: {
     description:
       "Optional host-brokered device capabilities. " +
-      "{ geolocation: { getCurrentPosition(options?) -> Promise<{ latitude, longitude, accuracy }> } }. " +
-      "Backs useGeolocation(). The web Player brokers it via navigator.geolocation; the Expo export via expo-location. " +
-      "getCurrentPosition rejects with a GeolocationError (.code PERMISSION_DENIED | UNAVAILABLE | TIMEOUT | UNSUPPORTED | INTERNAL).",
+      "{ geolocation: { getCurrentPosition(options?) -> Promise<{ latitude, longitude, accuracy }> }, " +
+      "speech: { isSupported() -> boolean, start(options, { onResult, onError, onEnd }) -> Promise<{ stop(), abort() }> } }. " +
+      "Backs useGeolocation() and useSpeechToText(). The web Player brokers them via navigator.geolocation and " +
+      "window.SpeechRecognition; the Expo export via expo-location and expo-speech-recognition. " +
+      "getCurrentPosition rejects with a GeolocationError (.code PERMISSION_DENIED | UNAVAILABLE | TIMEOUT | UNSUPPORTED | INTERNAL). " +
+      "speech.start streams { transcript, isFinal } to onResult and runs ON DEVICE — it uploads no audio and spends no AI credit; " +
+      "its onError carries the Web Speech error vocabulary (not-allowed | no-speech | language-not-supported | network | aborted).",
     required: false,
-    fields: { geolocation: "object" },
+    fields: { geolocation: "object", speech: "object" },
   },
 };
 
@@ -2787,7 +2848,14 @@ const CONTRACT = deepFreeze({
   //    Naming one widget is strictly more specific than restyling a scope, and
   //    the Properties Panel stays the final word. Additive throughout: a theme
   //    that sets none of it resolves exactly as before.
-  version: "1.62.0",
+  // 1.63.0: additive (sc-4915) — a manifest action declares `triggerTypes`, a
+  //    non-empty ARRAY, so one script can serve a create, an update and a
+  //    delete instead of being copied into three actions. The pre-sc-4915
+  //    scalar `triggerType` is still read and normalised, so an already
+  //    published widget keeps validating. The script's `triggerType` global
+  //    now names the trigger that actually FIRED the run ('manual' and 'app'
+  //    included), which is what makes a multi-trigger script able to branch.
+  version: "1.64.0",
   sharedTranslationKeys: SHARED_TRANSLATION_KEYS,
   hooks: HOOKS,
   primitives: PRIMITIVES,
@@ -3073,6 +3141,7 @@ export {
   CONTRACT,
   clampSpacingScale,
   scaleSpacing,
+  normaliseActionTriggerTypes,
   isHookAllowed,
   requiredContextKeys,
   isHexColor,

package/dist/hooks.js

@@ -916,6 +916,234 @@ export function useGeolocation(options) {
   };
 }
 
+/**
+ * Error surfaced by `useSpeechToText()` (thrown by `start()` and stored in the
+ * hook's `error` slot). Carries a stable `code` so widgets branch on the error
+ * class without parsing message strings.
+ *
+ * `code` is one of:
+ *   - "PERMISSION_DENIED"    — the user or OS refused microphone access.
+ *   - "NO_SPEECH"            — capture ended without any speech detected.
+ *   - "LANGUAGE_UNSUPPORTED" — no recogniser exists for the requested language.
+ *   - "NETWORK"              — the recogniser needed the network and failed.
+ *   - "ABORTED"              — capture was cancelled (abort(), or a new start()).
+ *   - "UNSUPPORTED"          — this host does not broker speech recognition.
+ *   - "INTERNAL"             — anything else.
+ */
+export class SpeechToTextError extends Error {
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "SpeechToTextError";
+    this.code = code;
+    if (opts && opts.cause) this.cause = opts.cause;
+  }
+}
+
+// Both hosts emit the Web Speech API's error vocabulary (the Expo export's
+// recogniser mirrors it deliberately), so one map serves web and native.
+const SPEECH_ERROR_CODES = {
+  "not-allowed": "PERMISSION_DENIED",
+  "service-not-allowed": "PERMISSION_DENIED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  "no-speech": "NO_SPEECH",
+  NO_SPEECH: "NO_SPEECH",
+  // Android's recogniser reports a silence timeout instead of "no-speech".
+  "speech-timeout": "NO_SPEECH",
+  "language-not-supported": "LANGUAGE_UNSUPPORTED",
+  LANGUAGE_UNSUPPORTED: "LANGUAGE_UNSUPPORTED",
+  network: "NETWORK",
+  NETWORK: "NETWORK",
+  aborted: "ABORTED",
+  ABORTED: "ABORTED",
+  UNSUPPORTED: "UNSUPPORTED",
+};
+
+/** Coerce a thrown/emitted value into a SpeechToTextError with a stable code. */
+function toSpeechToTextError(err) {
+  if (err instanceof SpeechToTextError) return err;
+  const raw =
+    err && err.code !== undefined && err.code !== null ? err.code : null;
+  const code = (raw !== null && SPEECH_ERROR_CODES[raw]) || "INTERNAL";
+  const message =
+    (err && typeof err.message === "string" && err.message) ||
+    "Speech recognition failed";
+  return new SpeechToTextError(code, message, { cause: err });
+}
+
+/**
+ * Dictate into text with the device's on-device speech recogniser. Returns
+ * `{ transcript, partial, listening, supported, error, start, stop, abort,
+ * reset }`.
+ *
+ * Capture is IMPERATIVE — call `start()` from a user gesture (a tap on a mic
+ * button). Both the browser and the mobile OS gate the microphone prompt on a
+ * user gesture, so the hook never listens on mount.
+ *
+ * `transcript` accumulates finalised speech; `partial` holds the in-flight
+ * guess the recogniser has not committed yet (empty unless
+ * `options.interimResults`). `stop()` finalises and keeps what was heard;
+ * `abort()` discards it. `reset()` clears both back to empty.
+ *
+ * Recognition runs ON DEVICE — no audio is uploaded and no AI credit is spent.
+ * The SAME hook drives both platforms: the web Player brokers it through the
+ * browser's SpeechRecognition, the Expo export through
+ * expo-speech-recognition.
+ *
+ * Safe-by-default: on a host that does not inject `ctx.device.speech` (or a
+ * browser without SpeechRecognition), `supported` is false and `start()`
+ * rejects with `code: "UNSUPPORTED"` rather than throwing at render, so a
+ * widget can call the hook unconditionally and hide its mic button.
+ */
+export function useSpeechToText(options) {
+  const ctx = useWidgetContextOrThrow("useSpeechToText");
+  const [transcript, setTranscript] = useState("");
+  const [partial, setPartial] = useState("");
+  const [listening, setListening] = useState(false);
+  const [error, setError] = useState(null);
+
+  // `ctx` is a fresh identity every host render — hold the live client and
+  // options in refs so the returned callbacks stay stable.
+  const clientRef = useRef(ctx.device && ctx.device.speech);
+  clientRef.current = ctx.device && ctx.device.speech;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  // The live capture session, so stop/abort/unmount can reach it.
+  const sessionRef = useRef(null);
+  const runRef = useRef(0);
+
+  const supported = Boolean(
+    clientRef.current &&
+    typeof clientRef.current.start === "function" &&
+    (typeof clientRef.current.isSupported !== "function" ||
+      clientRef.current.isSupported()),
+  );
+
+  // Abandoning a mounted recogniser leaves the mic hot on both hosts, so
+  // release it when the widget unmounts.
+  useEffect(
+    () => () => {
+      runRef.current += 1;
+      const session = sessionRef.current;
+      sessionRef.current = null;
+      if (session && typeof session.abort === "function") {
+        try {
+          session.abort();
+        } catch {
+          /* the host is already tearing the session down */
+        }
+      }
+    },
+    [],
+  );
+
+  const reset = useCallback(() => {
+    setTranscript("");
+    setPartial("");
+    setError(null);
+  }, []);
+
+  const stop = useCallback(async () => {
+    const session = sessionRef.current;
+    sessionRef.current = null;
+    setListening(false);
+    setPartial("");
+    if (session && typeof session.stop === "function") await session.stop();
+  }, []);
+
+  const abort = useCallback(() => {
+    runRef.current += 1;
+    const session = sessionRef.current;
+    sessionRef.current = null;
+    setListening(false);
+    setPartial("");
+    if (session && typeof session.abort === "function") session.abort();
+  }, []);
+
+  const start = useCallback(async () => {
+    const client = clientRef.current;
+    if (
+      !client ||
+      typeof client.start !== "function" ||
+      (typeof client.isSupported === "function" && !client.isSupported())
+    ) {
+      const e = new SpeechToTextError(
+        "UNSUPPORTED",
+        "This host does not provide speech recognition.",
+      );
+      setError(e);
+      setListening(false);
+      throw e;
+    }
+    // A second start() supersedes the first: drop the old session's events.
+    const myRun = ++runRef.current;
+    const previous = sessionRef.current;
+    sessionRef.current = null;
+    if (previous && typeof previous.abort === "function") previous.abort();
+
+    setError(null);
+    setPartial("");
+    setListening(true);
+    try {
+      const session = await client.start(optionsRef.current || {}, {
+        onResult: (result) => {
+          if (runRef.current !== myRun) return;
+          const text =
+            result && typeof result.transcript === "string"
+              ? result.transcript
+              : "";
+          if (result && result.isFinal) {
+            setPartial("");
+            // Append rather than replace: a continuous session emits one final
+            // result per utterance, not a growing whole.
+            setTranscript((prev) => (prev ? `${prev} ${text}`.trim() : text));
+          } else {
+            setPartial(text);
+          }
+        },
+        onError: (err) => {
+          if (runRef.current !== myRun) return;
+          sessionRef.current = null;
+          setError(toSpeechToTextError(err));
+          setPartial("");
+          setListening(false);
+        },
+        onEnd: () => {
+          if (runRef.current !== myRun) return;
+          sessionRef.current = null;
+          setPartial("");
+          setListening(false);
+        },
+      });
+      if (runRef.current !== myRun) {
+        // Superseded while the host was still opening the mic.
+        if (session && typeof session.abort === "function") session.abort();
+        return;
+      }
+      sessionRef.current = session || null;
+    } catch (err) {
+      const se = toSpeechToTextError(err);
+      if (runRef.current === myRun) {
+        sessionRef.current = null;
+        setError(se);
+        setListening(false);
+      }
+      throw se;
+    }
+  }, []);
+
+  return {
+    transcript,
+    partial,
+    listening,
+    supported,
+    error,
+    start,
+    stop,
+    abort,
+    reset,
+  };
+}
+
 /* ============================================================================
  * DATASTORE CLIENT — ctx.datastore (@colixsystems/datastore-client)
  *

package/dist/index.d.ts

@@ -223,18 +223,23 @@ export interface WidgetManifestAction {
   key: string;
   name: string;
   description?: string;
-  triggerType:
-    | "schedule"
-    | "record_created"
-    | "record_updated"
-    | "record_deleted";
-  /** Required iff `triggerType === "schedule"`. node-cron syntax. */
+  /**
+   * sc-4915 — a non-empty set of unique triggers. Combine them so one script
+   * serves several events; the script's `triggerType` global names the one
+   * that actually fired.
+   */
+  triggerTypes: Array<
+    "schedule" | "record_created" | "record_updated" | "record_deleted"
+  >;
+  /** Required iff `triggerTypes` contains `"schedule"`. node-cron syntax. */
   scheduleCron?: string;
   /** 100–300000. Defaults to 30000 on materialise. */
   timeoutMs?: number;
   /**
    * Runs against `datastore`, `fetch`, `console`, `record`, `tenantId`,
    * `triggerType`, `triggerTableId` — NOT the React/SDK surface. ≤ 200 KiB.
+   * `triggerType` is the trigger that fired THIS run — one of the declared
+   * `triggerTypes`, or `"manual"` / `"app"` for an operator or button run.
    */
   scriptSource: string;
 }
@@ -585,8 +590,22 @@ export interface WidgetContext<TProps = unknown> {
   toast?: {
     showToast(args: { kind?: string; message: string }): void;
   };
-  /** Optional host-brokered device capabilities; backs useGeolocation. */
+  /**
+   * Optional host-brokered device capabilities; backs useGeolocation and
+   * useSpeechToText.
+   */
   device?: {
+    speech?: {
+      isSupported?(): boolean;
+      start(
+        options: SpeechToTextOptions,
+        handlers: {
+          onResult(result: { transcript: string; isFinal: boolean }): void;
+          onError(error: unknown): void;
+          onEnd(): void;
+        },
+      ): Promise<{ stop(): void | Promise<void>; abort(): void }>;
+    };
     geolocation?: {
       getCurrentPosition(options?: GeolocationOptions): Promise<{
         latitude: number;
@@ -1262,6 +1281,68 @@ export class GeolocationError extends Error {
   );
 }
 
+/** Pass-through options for `useSpeechToText(...)`. */
+export interface SpeechToTextOptions {
+  /** BCP-47 tag, e.g. "sv-SE". Defaults to the host's UI language. */
+  lang?: string;
+  /** Keep listening across pauses instead of stopping at the first result. */
+  continuous?: boolean;
+  /** Emit uncommitted guesses to `partial` while the user is still speaking. */
+  interimResults?: boolean;
+}
+
+export interface SpeechToTextResult {
+  /** Finalised speech, accumulated across utterances in this session. */
+  transcript: string;
+  /** The uncommitted guess; `""` unless `interimResults` was requested. */
+  partial: string;
+  listening: boolean;
+  /** False when the host brokers no recogniser (e.g. Firefox). */
+  supported: boolean;
+  error: SpeechToTextError | null;
+  /** Begin listening — call from a user gesture. Rejects with SpeechToTextError. */
+  start(): Promise<void>;
+  /** Stop listening and keep what was heard. */
+  stop(): Promise<void>;
+  /** Cancel listening and discard the current utterance. */
+  abort(): void;
+  /** Clear `transcript`, `partial`, and `error`. */
+  reset(): void;
+}
+
+/**
+ * Dictate into text with the device's ON-DEVICE speech recogniser. Capture is
+ * imperative (call `start()` from a user gesture; it never listens on mount).
+ * The same hook drives both platforms — the web Player brokers it via
+ * `window.SpeechRecognition`, the Expo export via `expo-speech-recognition`.
+ * No audio is uploaded and no AI credit is spent. Safe to call on a host that
+ * brokers no recogniser: `supported` is then false and `start()` rejects with
+ * `code: "UNSUPPORTED"`, so gate the mic button on `supported`.
+ */
+export function useSpeechToText(
+  options?: SpeechToTextOptions,
+): SpeechToTextResult;
+
+/**
+ * Error surfaced by `useSpeechToText()` — thrown by `start()` and stored in the
+ * hook's `error` slot. `code` is a stable categorisation.
+ */
+export class SpeechToTextError extends Error {
+  code:
+    | "PERMISSION_DENIED"
+    | "NO_SPEECH"
+    | "LANGUAGE_UNSUPPORTED"
+    | "NETWORK"
+    | "ABORTED"
+    | "UNSUPPORTED"
+    | "INTERNAL";
+  constructor(
+    code: SpeechToTextError["code"],
+    message: string,
+    opts?: { cause?: unknown },
+  );
+}
+
 /**
  * Error class thrown by useDatastoreMutation callbacks (and surfaced by
  * useDatastoreQuery in its `error` slot). The `code` is a stable

package/dist/index.js

@@ -56,6 +56,8 @@ export {
   useContainerWidth,
   useGeolocation,
   GeolocationError,
+  useSpeechToText,
+  SpeechToTextError,
   WidgetTree,
 } from "./hooks.js";
 export { isNarrowWidth, NARROW_WIDTH_PX } from "./container-width.js";

package/dist/index.native.js

@@ -56,6 +56,8 @@ export {
   useContainerWidth,
   useGeolocation,
   GeolocationError,
+  useSpeechToText,
+  SpeechToTextError,
   WidgetTree,
 } from "./hooks.js";
 export { isNarrowWidth, NARROW_WIDTH_PX } from "./container-width.js";

package/dist/linter.cjs

@@ -10,7 +10,7 @@
 
 "use strict";
 
-const { CONTRACT } = require("./contract.cjs");
+const { CONTRACT, normaliseActionTriggerTypes } = require("./contract.cjs");
 const { LUCIDE_ICON_NAMES, LUCIDE_VERSION } = require("./lucideIconNames.cjs");
 
 function _ruleForIdentifier(identifier, reason) {
@@ -579,10 +579,11 @@ function _manifestActionRules(manifest) {
     if (typeof a.name !== "string" || a.name.length === 0) {
       push("manifest.actions[].name must be a non-empty string");
     }
-    if (!validTriggers.has(a.triggerType)) {
-      push(`manifest.actions[].triggerType must be one of ${[...validTriggers].join(", ")}`);
-    } else if (a.triggerType === "schedule" && (typeof a.scheduleCron !== "string" || !a.scheduleCron)) {
-      push("manifest.actions[].scheduleCron is required when triggerType is 'schedule'");
+    const triggerTypes = normaliseActionTriggerTypes(a);
+    if (triggerTypes === null) {
+      push(`manifest.actions[].triggerTypes must be a non-empty array of unique values from ${[...validTriggers].join(", ")}`);
+    } else if (triggerTypes.includes("schedule") && (typeof a.scheduleCron !== "string" || !a.scheduleCron)) {
+      push("manifest.actions[].scheduleCron is required when triggerTypes contains 'schedule'");
     }
     if (typeof a.scriptSource !== "string" || a.scriptSource.length === 0) {
       push("manifest.actions[].scriptSource must be a non-empty string");

package/dist/linter.js

@@ -6,7 +6,7 @@
 // The banned-identifier list is derived from `CONTRACT.bannedApis` so the
 // system prompt, the linter, and the runtime allowlist agree.
 
-import { CONTRACT } from "./contract.js";
+import { CONTRACT, normaliseActionTriggerTypes } from "./contract.js";
 import { LUCIDE_ICON_NAMES, LUCIDE_VERSION } from "./lucideIconNames.js";
 
 // Per-identifier match rule. Most banned identifiers compile to a
@@ -674,16 +674,17 @@ function _manifestActionRules(manifest) {
     if (typeof a.name !== "string" || a.name.length === 0) {
       push("manifest.actions[].name must be a non-empty string");
     }
-    if (!validTriggers.has(a.triggerType)) {
+    const triggerTypes = normaliseActionTriggerTypes(a);
+    if (triggerTypes === null) {
       push(
-        `manifest.actions[].triggerType must be one of ${[...validTriggers].join(", ")}`,
+        `manifest.actions[].triggerTypes must be a non-empty array of unique values from ${[...validTriggers].join(", ")}`,
       );
     } else if (
-      a.triggerType === "schedule" &&
+      triggerTypes.includes("schedule") &&
       (typeof a.scheduleCron !== "string" || !a.scheduleCron)
     ) {
       push(
-        "manifest.actions[].scheduleCron is required when triggerType is 'schedule'",
+        "manifest.actions[].scheduleCron is required when triggerTypes contains 'schedule'",
       );
     }
     if (typeof a.scriptSource !== "string" || a.scriptSource.length === 0) {

package/dist/manifest.cjs

@@ -4,7 +4,7 @@
 // re-exports the same functions defined here so there is exactly one
 // implementation.
 
-const { CONTRACT } = require("./contract.cjs");
+const { CONTRACT, normaliseActionTriggerTypes } = require("./contract.cjs");
 
 const PAYLOAD_VALUE_TYPES = CONTRACT.payloadValueTypes;
 
@@ -152,15 +152,16 @@ function validateManifestActions(actions, errors) {
       seenKeys.add(a.key);
     }
     pushIf(errors, isNonEmptyString(a.name), "manifest.actions[].name must be a non-empty string");
-    if (!VALID_ACTION_TRIGGERS.has(a.triggerType)) {
+    const triggerTypes = normaliseActionTriggerTypes(a);
+    if (triggerTypes === null) {
       errors.push(
-        `manifest.actions[].triggerType must be one of ${[...VALID_ACTION_TRIGGERS].join(", ")}`,
+        `manifest.actions[].triggerTypes must be a non-empty array of unique values from ${[...VALID_ACTION_TRIGGERS].join(", ")}`,
       );
-    } else if (a.triggerType === "schedule") {
+    } else if (triggerTypes.includes("schedule")) {
       pushIf(
         errors,
         isNonEmptyString(a.scheduleCron),
-        "manifest.actions[].scheduleCron is required when triggerType is 'schedule'",
+        "manifest.actions[].scheduleCron is required when triggerTypes contains 'schedule'",
       );
     }
     if (!isNonEmptyString(a.scriptSource)) {

package/dist/manifest.js

@@ -4,7 +4,7 @@
 // re-exports the same functions defined here so there is exactly one
 // implementation.
 
-import { CONTRACT } from "./contract.js";
+import { CONTRACT, normaliseActionTriggerTypes } from "./contract.js";
 
 const PAYLOAD_VALUE_TYPES = CONTRACT.payloadValueTypes;
 
@@ -152,15 +152,16 @@ function validateManifestActions(actions, errors) {
       seenKeys.add(a.key);
     }
     pushIf(errors, isNonEmptyString(a.name), "manifest.actions[].name must be a non-empty string");
-    if (!VALID_ACTION_TRIGGERS.has(a.triggerType)) {
+    const triggerTypes = normaliseActionTriggerTypes(a);
+    if (triggerTypes === null) {
       errors.push(
-        `manifest.actions[].triggerType must be one of ${[...VALID_ACTION_TRIGGERS].join(", ")}`,
+        `manifest.actions[].triggerTypes must be a non-empty array of unique values from ${[...VALID_ACTION_TRIGGERS].join(", ")}`,
       );
-    } else if (a.triggerType === "schedule") {
+    } else if (triggerTypes.includes("schedule")) {
       pushIf(
         errors,
         isNonEmptyString(a.scheduleCron),
-        "manifest.actions[].scheduleCron is required when triggerType is 'schedule'",
+        "manifest.actions[].scheduleCron is required when triggerTypes contains 'schedule'",
       );
     }
     if (!isNonEmptyString(a.scriptSource)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colixsystems/widget-sdk",
-  "version": "0.89.0",
+  "version": "0.91.0",
   "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-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-measured-padding.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 src/__tests__/toast-host.test.js src/__tests__/hooks-domain-error-mapping.test.js src/__tests__/linter-datastore-error.test.js src/__tests__/linter-write-gating.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-measured-padding.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 src/__tests__/toast-host.test.js src/__tests__/hooks-domain-error-mapping.test.js src/__tests__/linter-datastore-error.test.js src/__tests__/linter-write-gating.test.js src/__tests__/hooks-speech-to-text.test.js"
   },
   "engines": {
     "node": ">=18"