@civitai/blocks-react 0.67.1 → 0.68.0

package/dist/transport/validate.js

@@ -232,6 +232,13 @@ export function isValidWorkflowSnapshot(s) {
     if (s.cost !== undefined) {
         if (!isObject(s.cost) || typeof s.cost.total !== 'number')
             return false;
+        // OPTIONAL: an older host omits it and the snapshot stays valid. Present, it
+        // is subtracted from `total` by the block, so a non-number or a negative
+        // would render a wrong price.
+        if (s.cost.authorFee !== undefined &&
+            (!isFiniteNumber(s.cost.authorFee) || s.cost.authorFee < 0)) {
+            return false;
+        }
     }
     if (s.imageUrls !== undefined) {
         if (!Array.isArray(s.imageUrls))
@@ -513,6 +520,44 @@ export function isValidWorkflowReply(p) {
         return false;
     return true;
 }
+/**
+ * Reply to a block-initiated `ESTIMATE_WORKFLOW_BATCH`. A well-formed reply
+ * carries EITHER an `error` string OR `snapshots` + `aggregate`.
+ *
+ * 🔴 A PRESENT `error` IS ACCEPTED ON ITS OWN, unlike the single-estimate reply
+ * ({@link isValidWorkflowReply}, which requires a snapshot). That is what lets
+ * the host's generic `{ requestId, error: 'unsupported on this host' }` reach
+ * `useBatchEstimate`, which turns it into the typed error an app falls back to
+ * per-cell estimates on. Dropping it would leave the block waiting out the
+ * timeout instead. `error` is shape-checked only: the channel carries free-text
+ * server messages.
+ *
+ * Without an `error`, EVERY cell must be a valid workflow snapshot and the
+ * aggregate must hold three finite numbers. One malformed cell rejects the whole
+ * reply, the same way one malformed snapshot rejects a single-estimate reply:
+ * the block dereferences these fields.
+ */
+export function isValidEstimateBatchResult(p) {
+    if (!isObject(p))
+        return false;
+    if (!isWireRequestIdShape(p.requestId))
+        return false;
+    if (p.error !== undefined)
+        return typeof p.error === 'string';
+    if (!Array.isArray(p.snapshots))
+        return false;
+    if (!p.snapshots.every((s) => isValidWorkflowSnapshot(s)))
+        return false;
+    const a = p.aggregate;
+    if (!isObject(a))
+        return false;
+    for (const key of ['total', 'pricedCells', 'cellCount']) {
+        const value = a[key];
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return false;
+    }
+    return true;
+}
 export function isValidBuzzPurchaseResult(p) {
     if (!isObject(p))
         return false;
@@ -1478,6 +1523,10 @@ export function isValidAppStorageQuotaResult(p) {
 // uniform). Closes the silent-corrupt-return hole: without these,
 // `getCount/getCounts/append/vote/unvote`/`list` returned a missing field as
 // `undefined` typed `number`/`string` with no throw, no timeout.
+//
+// The optional `rateLimit` on the six write replies is NOT checked by any
+// predicate here, so it can never drop a reply; the hook parses it (see
+// `parseSharedStorageRateLimit` below the validators).
 /** The moderated `{ title, body?, data? }` value carried by each SHARED entry. */
 function isValidSharedValue(v) {
     if (!isObject(v))
@@ -1676,6 +1725,36 @@ export function isValidSharedWithdrawResult(p) {
         return false;
     return true;
 }
+/**
+ * Validate the `rateLimit` a host put on a shared-storage refusal. Returns a
+ * copy holding ONLY the two known fields, or `undefined` when `value` is
+ * missing or malformed.
+ *
+ * Kept in lockstep with the platform's own parser for the same metadata
+ * (`parseRateLimitMeta` in civitai's `src/shared/utils/rate-limit-meta.ts`):
+ * `retryAfterSeconds` must be an integer of at least 1, and `retryAt` a string
+ * `Date.parse` can read. Anything else — a wrong type, a negative or fractional
+ * number, a missing field, a non-object — is malformed.
+ *
+ * 🔴 NOT A VALIDATOR, deliberately. None of the `isValidShared*Result`
+ * predicates look at `rateLimit`, so a malformed one can never DROP a reply:
+ * dropping it would hang the block's request to its timeout over an optional
+ * hint. The reply is delivered unchanged, and `useSharedStorage` calls this
+ * parser: a malformed value is ignored and the plain refusal error is thrown.
+ */
+export function parseSharedStorageRateLimit(value) {
+    if (!isObject(value))
+        return undefined;
+    const { retryAfterSeconds, retryAt } = value;
+    if (typeof retryAfterSeconds !== 'number' || !Number.isInteger(retryAfterSeconds)) {
+        return undefined;
+    }
+    if (retryAfterSeconds < 1)
+        return undefined;
+    if (typeof retryAt !== 'string' || Number.isNaN(Date.parse(retryAt)))
+        return undefined;
+    return { retryAfterSeconds, retryAt };
+}
 // ============================================================
 // Picker + user-checkpoint reply validators
 // ============================================================
@@ -1723,42 +1802,65 @@ export function isValidCheckpointPickerResult(p) {
     return true;
 }
 /**
- * Reply to `OPEN_RESOURCE_PICKER`. `selected` is ABSENT on dismiss (the hook
- * resolves `null`); when present it is a `BlockResourceInfo` projection — the 5
- * base fields plus `modelType` and the OPTIONAL public recommended-settings
- * (`strength`/`minStrength`/`maxStrength` finite, `trainedWords` a string[],
- * `clipSkip` a finite number OR `null`).
+ * One `BlockResourceInfo` projection — the 5 base fields plus `modelType` and
+ * the OPTIONAL public recommended-settings (`strength`/`minStrength`/
+ * `maxStrength` finite, `trainedWords` a string[], `clipSkip` a finite number
+ * OR `null`). Shared by the single-pick `selected` and every entry of the
+ * multi-select `selectedResources`, so the two cannot drift on what a
+ * well-formed resource is.
+ */
+function isValidPickerResource(s) {
+    if (!isObject(s))
+        return false;
+    if (!isValidPickerResourceBase(s))
+        return false;
+    if (s.modelType !== undefined && typeof s.modelType !== 'string')
+        return false;
+    if (s.strength !== undefined && !isFiniteNumber(s.strength))
+        return false;
+    if (s.minStrength !== undefined && !isFiniteNumber(s.minStrength))
+        return false;
+    if (s.maxStrength !== undefined && !isFiniteNumber(s.maxStrength))
+        return false;
+    if (s.trainedWords !== undefined) {
+        if (!Array.isArray(s.trainedWords))
+            return false;
+        if (!s.trainedWords.every((w) => typeof w === 'string'))
+            return false;
+    }
+    // `clipSkip` is `number | null` — accept a finite number OR null; reject
+    // other present types.
+    if (s.clipSkip !== undefined && s.clipSkip !== null && !isFiniteNumber(s.clipSkip)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Reply to `OPEN_RESOURCE_PICKER`.
+ *
+ * Single pick: `selected` is ABSENT on dismiss (the hook resolves `null`); when
+ * present it is a `BlockResourceInfo` projection.
+ *
+ * Multi-select: `selectedResources` is an array of the same projection (`[]` on
+ * dismiss). ONE malformed entry drops the whole reply — each `versionId` is
+ * money-adjacent, and handing the caller the well-formed remainder would
+ * silently change which resources a generation runs with.
+ *
+ * `error` (a refusal) is not validated here: the hook reads it by PRESENCE, and
+ * a reply carrying only `{ requestId, error }` must reach it.
  */
 export function isValidResourcePickerResult(p) {
     if (!isObject(p))
         return false;
     if (!isWireRequestIdShape(p.requestId))
         return false;
-    if (p.selected !== undefined) {
-        const s = p.selected;
-        if (!isObject(s))
-            return false;
-        if (!isValidPickerResourceBase(s))
-            return false;
-        if (s.modelType !== undefined && typeof s.modelType !== 'string')
-            return false;
-        if (s.strength !== undefined && !isFiniteNumber(s.strength))
-            return false;
-        if (s.minStrength !== undefined && !isFiniteNumber(s.minStrength))
+    if (p.selected !== undefined && !isValidPickerResource(p.selected))
+        return false;
+    if (p.selectedResources !== undefined) {
+        if (!Array.isArray(p.selectedResources))
             return false;
-        if (s.maxStrength !== undefined && !isFiniteNumber(s.maxStrength))
+        if (!p.selectedResources.every(isValidPickerResource))
             return false;
-        if (s.trainedWords !== undefined) {
-            if (!Array.isArray(s.trainedWords))
-                return false;
-            if (!s.trainedWords.every((w) => typeof w === 'string'))
-                return false;
-        }
-        // `clipSkip` is `number | null` — accept a finite number OR null; reject
-        // other present types.
-        if (s.clipSkip !== undefined && s.clipSkip !== null && !isFiniteNumber(s.clipSkip)) {
-            return false;
-        }
     }
     return true;
 }
@@ -1862,6 +1964,8 @@ export function payloadValidatorFor(type) {
         case 'WORKFLOW_STATUS':
         case 'WORKFLOW_CANCELED':
             return isValidWorkflowReply;
+        case 'ESTIMATE_BATCH_RESULT':
+            return isValidEstimateBatchResult;
         case 'BUZZ_PURCHASE_RESULT':
             return isValidBuzzPurchaseResult;
         case 'BUZZ_BALANCE_RESULT':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civitai/blocks-react",
-  "version": "0.67.1",
+  "version": "0.68.0",
   "description": "React hooks and iframe transport for Civitai Apps. Pairs with @civitai/app-sdk/blocks.",
   "license": "MIT",
   "type": "module",
@@ -58,7 +58,7 @@
     "typescript": "^5.9.2",
     "vite": "^8.0.14",
     "vitest": "^4.1.11",
-    "@civitai/app-sdk": "^0.63.0"
+    "@civitai/app-sdk": "^0.64.0"
   },
   "publishConfig": {
     "access": "public"