@reventlessdev/reventless-seed-aws 1.0.0-alpha.24 → 1.0.0-alpha.26

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.26 (2026-08-27)
+
+**Note:** Version bump only for package @reventlessdev/reventless-seed-aws
+
+
+
+
+
+# 1.0.0-alpha.25 (2026-08-27)
+
+### Bug Fixes
+
+* **seed-aws:** a throttled control plane aborts the reset hold and blames IAM ([95af263](https://github.com/ReventlessDev/reventless-core/commit/95af263afba7dfdfa9a7fc45f494b302dba4baf8))
+
+
 # 1.0.0-alpha.24 (2026-08-23)
 
 **Note:** Version bump only for package @reventlessdev/reventless-seed-aws

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1787445581444)
-#Done(1787445581485)
+#Start(1787841680994)
+#Done(1787841681025)

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "c18a0067c363fd1290f6e7f6fe6212d2e16e201c1702fac667962047f88ed468",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1787445581490"
+  "generated_at": "1787841681029"
 }

package/lib/bs/src/ReventlessSeedAws_Quiesce.res

@@ -86,6 +86,17 @@ let mapBounded = async (items: array<'a>, ~limit: int, f: 'a => promise<'b>): ar
 let errorText = (exn: exn): string =>
   exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
 
+/** A throttle and a missing permission both surface as a failure to hold, and
+    they call for opposite responses — wait and re-run, versus go and fix the
+    policy. The control plane says "Rate exceeded"; the SDK says
+    "TooManyRequestsException". Match on either. */
+let isThrottle = (reason: string): bool => {
+  let r = reason->String.toLowerCase
+  r->String.includes("rate exceeded") ||
+  r->String.includes("toomanyrequests") ||
+  r->String.includes("throttl")
+}
+
 // An update is rejected while another is still settling, and a stack that was
 // deployed moments ago can still be settling. Poll rather than assume.
 let awaitSettled = async (~client, ~functionName: string): unit => {
@@ -269,14 +280,21 @@ let hold = async (~client, ~functionNames: array<string>): array<held> => {
   | Some((functionName, reason)) =>
     let rollback = await taken->mapBounded(~limit=concurrency, h => restoreConcurrency(~client, ~h))
     let stranded = rollback->Array.filterMap(w => w)
+    let advice = if reason->isThrottle {
+      `The Lambda control plane throttled the hold. That budget is per account and region and is ` ++
+      `shared with anything else using it — a deploy, an inspector sync, another stack in the same ` ++
+      `region — so this is transient and nothing is wrong with the credentials. Wait for whatever ` ++
+      `else is running to finish and re-run.`
+    } else {
+      `The reset holds every runtime in scope for the length of the wipe, which needs ` ++
+      `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
+      `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration.`
+    }
     throw(
       ReventlessSeed.Seed.Failed(
         `could not hold Lambda function ${functionName} at zero concurrency (${reason}) — nothing was ` ++
-        `deleted. The reset holds every runtime in scope for the length of the wipe, which needs ` ++
-        `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
-        `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration. Set ` ++
-        `SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running runtime can then write back ` ++
-        `what the wipe removes.` ++
+        `deleted. ${advice} Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running ` ++
+        `runtime can then write back what the wipe removes.` ++
         switch stranded {
         | [] => ""
         | messages => `\n\n  ` ++ messages->Array.join("\n  ")

package/lib/bs/src/ReventlessSeedAws_Quiesce.res.mjs

@@ -37,6 +37,15 @@ function errorText(exn) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
 }
 
+function isThrottle(reason) {
+  let r = reason.toLowerCase();
+  if (r.includes("rate exceeded") || r.includes("toomanyrequests")) {
+    return true;
+  } else {
+    return r.includes("throttl");
+  }
+}
+
 async function awaitSettled(client, functionName) {
   let poll = async attempt => {
     if (attempt >= 60) {
@@ -174,11 +183,13 @@ async function hold(client, functionNames) {
   if (match === undefined) {
     return taken;
   }
+  let reason = match[1];
   let rollback = await mapBounded(taken, 6, h => restoreConcurrency(client, h));
   let stranded = Stdlib_Array.filterMap(rollback, w => w);
+  let advice = isThrottle(reason) ? `The Lambda control plane throttled the hold. That budget is per account and region and is shared with anything else using it — a deploy, an inspector sync, another stack in the same region — so this is transient and nothing is wrong with the credentials. Wait for whatever else is running to finish and re-run.` : `The reset holds every runtime in scope for the length of the wipe, which needs lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration.`;
   throw {
     RE_EXN_ID: Seed$ReventlessSeed.Failed,
-    _1: `could not hold Lambda function ` + match[0] + ` at zero concurrency (` + match[1] + `) — nothing was deleted. The reset holds every runtime in scope for the length of the wipe, which needs lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration. Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running runtime can then write back what the wipe removes.` + (
+    _1: `could not hold Lambda function ` + match[0] + ` at zero concurrency (` + reason + `) — nothing was ` + (`deleted. ` + advice + ` Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running `) + `runtime can then write back what the wipe removes.` + (
       stranded.length !== 0 ? `\n\n  ` + stranded.join("\n  ") : ""
     ),
     Error: new Error()
@@ -195,6 +206,7 @@ export {
   concurrency,
   mapBounded,
   errorText,
+  isThrottle,
   awaitSettled,
   updateVariables,
   restoreConcurrency,

package/lib/bs/tests/QuiesceResetTest.res

@@ -109,6 +109,30 @@ describe("refillMessage", () => {
   })
 })
 
+describe("isThrottle", () => {
+  // A hold that fails because the control plane is busy and a hold that fails
+  // because the credentials are short a policy read identically at the call
+  // site, and the fixes point in opposite directions: wait, versus go and edit
+  // an IAM policy. Sending an operator to the policy for a throttle costs them
+  // the whole trip.
+  testSync("recognises the wordings a throttled hold actually comes back with", () =>
+    [
+      "Rate exceeded",
+      "TooManyRequestsException: Rate exceeded",
+      "Request throttled, please try again",
+    ]->Array.forEach(reason => expect(Quiesce.isThrottle(reason))->toBe(true))
+  )
+
+  testSync("leaves a permission failure to the IAM advice", () => {
+    expect(
+      Quiesce.isThrottle(
+        "AccessDeniedException: User is not authorized to perform: lambda:PutFunctionConcurrency",
+      ),
+    )->toBe(false)
+    expect(Quiesce.isThrottle("ResourceNotFoundException: Function not found"))->toBe(false)
+  })
+})
+
 describe("noQuiesce", () => {
   let set = v => NodeProcess.env->Dict.set("SEED_RESET_NO_QUIESCE", v)
 

package/lib/bs/tests/QuiesceResetTest.res.mjs

@@ -104,6 +104,22 @@ globalThis.describe("refillMessage", () => {
   });
 });
 
+globalThis.describe("isThrottle", () => {
+  globalThis.test("recognises the wordings a throttled hold actually comes back with", () => {
+    [
+      "Rate exceeded",
+      "TooManyRequestsException: Rate exceeded",
+      "Request throttled, please try again"
+    ].forEach(reason => {
+      globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle(reason)).toBe(true);
+    });
+  });
+  globalThis.test("leaves a permission failure to the IAM advice", () => {
+    globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle("AccessDeniedException: User is not authorized to perform: lambda:PutFunctionConcurrency")).toBe(false);
+    globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle("ResourceNotFoundException: Function not found")).toBe(false);
+  });
+});
+
 globalThis.describe("noQuiesce", () => {
   let set = v => {
     process.env["SEED_RESET_NO_QUIESCE"] = v;

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1787445581444)
-#Done(1787445581485)
+#Start(1787841680994)
+#Done(1787841681025)

package/lib/ocaml/QuiesceResetTest.res

@@ -109,6 +109,30 @@ describe("refillMessage", () => {
   })
 })
 
+describe("isThrottle", () => {
+  // A hold that fails because the control plane is busy and a hold that fails
+  // because the credentials are short a policy read identically at the call
+  // site, and the fixes point in opposite directions: wait, versus go and edit
+  // an IAM policy. Sending an operator to the policy for a throttle costs them
+  // the whole trip.
+  testSync("recognises the wordings a throttled hold actually comes back with", () =>
+    [
+      "Rate exceeded",
+      "TooManyRequestsException: Rate exceeded",
+      "Request throttled, please try again",
+    ]->Array.forEach(reason => expect(Quiesce.isThrottle(reason))->toBe(true))
+  )
+
+  testSync("leaves a permission failure to the IAM advice", () => {
+    expect(
+      Quiesce.isThrottle(
+        "AccessDeniedException: User is not authorized to perform: lambda:PutFunctionConcurrency",
+      ),
+    )->toBe(false)
+    expect(Quiesce.isThrottle("ResourceNotFoundException: Function not found"))->toBe(false)
+  })
+})
+
 describe("noQuiesce", () => {
   let set = v => NodeProcess.env->Dict.set("SEED_RESET_NO_QUIESCE", v)
 

package/lib/ocaml/ReventlessSeedAws_Quiesce.res

@@ -86,6 +86,17 @@ let mapBounded = async (items: array<'a>, ~limit: int, f: 'a => promise<'b>): ar
 let errorText = (exn: exn): string =>
   exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
 
+/** A throttle and a missing permission both surface as a failure to hold, and
+    they call for opposite responses — wait and re-run, versus go and fix the
+    policy. The control plane says "Rate exceeded"; the SDK says
+    "TooManyRequestsException". Match on either. */
+let isThrottle = (reason: string): bool => {
+  let r = reason->String.toLowerCase
+  r->String.includes("rate exceeded") ||
+  r->String.includes("toomanyrequests") ||
+  r->String.includes("throttl")
+}
+
 // An update is rejected while another is still settling, and a stack that was
 // deployed moments ago can still be settling. Poll rather than assume.
 let awaitSettled = async (~client, ~functionName: string): unit => {
@@ -269,14 +280,21 @@ let hold = async (~client, ~functionNames: array<string>): array<held> => {
   | Some((functionName, reason)) =>
     let rollback = await taken->mapBounded(~limit=concurrency, h => restoreConcurrency(~client, ~h))
     let stranded = rollback->Array.filterMap(w => w)
+    let advice = if reason->isThrottle {
+      `The Lambda control plane throttled the hold. That budget is per account and region and is ` ++
+      `shared with anything else using it — a deploy, an inspector sync, another stack in the same ` ++
+      `region — so this is transient and nothing is wrong with the credentials. Wait for whatever ` ++
+      `else is running to finish and re-run.`
+    } else {
+      `The reset holds every runtime in scope for the length of the wipe, which needs ` ++
+      `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
+      `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration.`
+    }
     throw(
       ReventlessSeed.Seed.Failed(
         `could not hold Lambda function ${functionName} at zero concurrency (${reason}) — nothing was ` ++
-        `deleted. The reset holds every runtime in scope for the length of the wipe, which needs ` ++
-        `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
-        `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration. Set ` ++
-        `SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running runtime can then write back ` ++
-        `what the wipe removes.` ++
+        `deleted. ${advice} Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running ` ++
+        `runtime can then write back what the wipe removes.` ++
         switch stranded {
         | [] => ""
         | messages => `\n\n  ` ++ messages->Array.join("\n  ")

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reventlessdev/reventless-seed-aws",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.26",
   "description": "AWS connect + guarded reset for the Reventless seed harness — stack discovery, Cognito login, and a tag-scoped, allowlisted store wipe",
   "license": "Apache-2.0",
   "dependencies": {
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.14",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.17",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.13"
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.18"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/ReventlessSeedAws_Quiesce.res

@@ -86,6 +86,17 @@ let mapBounded = async (items: array<'a>, ~limit: int, f: 'a => promise<'b>): ar
 let errorText = (exn: exn): string =>
   exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
 
+/** A throttle and a missing permission both surface as a failure to hold, and
+    they call for opposite responses — wait and re-run, versus go and fix the
+    policy. The control plane says "Rate exceeded"; the SDK says
+    "TooManyRequestsException". Match on either. */
+let isThrottle = (reason: string): bool => {
+  let r = reason->String.toLowerCase
+  r->String.includes("rate exceeded") ||
+  r->String.includes("toomanyrequests") ||
+  r->String.includes("throttl")
+}
+
 // An update is rejected while another is still settling, and a stack that was
 // deployed moments ago can still be settling. Poll rather than assume.
 let awaitSettled = async (~client, ~functionName: string): unit => {
@@ -269,14 +280,21 @@ let hold = async (~client, ~functionNames: array<string>): array<held> => {
   | Some((functionName, reason)) =>
     let rollback = await taken->mapBounded(~limit=concurrency, h => restoreConcurrency(~client, ~h))
     let stranded = rollback->Array.filterMap(w => w)
+    let advice = if reason->isThrottle {
+      `The Lambda control plane throttled the hold. That budget is per account and region and is ` ++
+      `shared with anything else using it — a deploy, an inspector sync, another stack in the same ` ++
+      `region — so this is transient and nothing is wrong with the credentials. Wait for whatever ` ++
+      `else is running to finish and re-run.`
+    } else {
+      `The reset holds every runtime in scope for the length of the wipe, which needs ` ++
+      `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
+      `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration.`
+    }
     throw(
       ReventlessSeed.Seed.Failed(
         `could not hold Lambda function ${functionName} at zero concurrency (${reason}) — nothing was ` ++
-        `deleted. The reset holds every runtime in scope for the length of the wipe, which needs ` ++
-        `lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, ` ++
-        `lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration. Set ` ++
-        `SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running runtime can then write back ` ++
-        `what the wipe removes.` ++
+        `deleted. ${advice} Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running ` ++
+        `runtime can then write back what the wipe removes.` ++
         switch stranded {
         | [] => ""
         | messages => `\n\n  ` ++ messages->Array.join("\n  ")

package/src/ReventlessSeedAws_Quiesce.res.mjs

@@ -37,6 +37,15 @@ function errorText(exn) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
 }
 
+function isThrottle(reason) {
+  let r = reason.toLowerCase();
+  if (r.includes("rate exceeded") || r.includes("toomanyrequests")) {
+    return true;
+  } else {
+    return r.includes("throttl");
+  }
+}
+
 async function awaitSettled(client, functionName) {
   let poll = async attempt => {
     if (attempt >= 60) {
@@ -174,11 +183,13 @@ async function hold(client, functionNames) {
   if (match === undefined) {
     return taken;
   }
+  let reason = match[1];
   let rollback = await mapBounded(taken, 6, h => restoreConcurrency(client, h));
   let stranded = Stdlib_Array.filterMap(rollback, w => w);
+  let advice = isThrottle(reason) ? `The Lambda control plane throttled the hold. That budget is per account and region and is shared with anything else using it — a deploy, an inspector sync, another stack in the same region — so this is transient and nothing is wrong with the credentials. Wait for whatever else is running to finish and re-run.` : `The reset holds every runtime in scope for the length of the wipe, which needs lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration.`;
   throw {
     RE_EXN_ID: Seed$ReventlessSeed.Failed,
-    _1: `could not hold Lambda function ` + match[0] + ` at zero concurrency (` + match[1] + `) — nothing was deleted. The reset holds every runtime in scope for the length of the wipe, which needs lambda:GetFunctionConcurrency, lambda:GetFunctionConfiguration, lambda:PutFunctionConcurrency, lambda:DeleteFunctionConcurrency and lambda:UpdateFunctionConfiguration. Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running runtime can then write back what the wipe removes.` + (
+    _1: `could not hold Lambda function ` + match[0] + ` at zero concurrency (` + reason + `) — nothing was ` + (`deleted. ` + advice + ` Set SEED_RESET_NO_QUIESCE=1 to wipe without the hold — but a running `) + `runtime can then write back what the wipe removes.` + (
       stranded.length !== 0 ? `\n\n  ` + stranded.join("\n  ") : ""
     ),
     Error: new Error()
@@ -195,6 +206,7 @@ export {
   concurrency,
   mapBounded,
   errorText,
+  isThrottle,
   awaitSettled,
   updateVariables,
   restoreConcurrency,

package/tests/QuiesceResetTest.res

@@ -109,6 +109,30 @@ describe("refillMessage", () => {
   })
 })
 
+describe("isThrottle", () => {
+  // A hold that fails because the control plane is busy and a hold that fails
+  // because the credentials are short a policy read identically at the call
+  // site, and the fixes point in opposite directions: wait, versus go and edit
+  // an IAM policy. Sending an operator to the policy for a throttle costs them
+  // the whole trip.
+  testSync("recognises the wordings a throttled hold actually comes back with", () =>
+    [
+      "Rate exceeded",
+      "TooManyRequestsException: Rate exceeded",
+      "Request throttled, please try again",
+    ]->Array.forEach(reason => expect(Quiesce.isThrottle(reason))->toBe(true))
+  )
+
+  testSync("leaves a permission failure to the IAM advice", () => {
+    expect(
+      Quiesce.isThrottle(
+        "AccessDeniedException: User is not authorized to perform: lambda:PutFunctionConcurrency",
+      ),
+    )->toBe(false)
+    expect(Quiesce.isThrottle("ResourceNotFoundException: Function not found"))->toBe(false)
+  })
+})
+
 describe("noQuiesce", () => {
   let set = v => NodeProcess.env->Dict.set("SEED_RESET_NO_QUIESCE", v)
 

package/tests/QuiesceResetTest.res.mjs

@@ -104,6 +104,22 @@ globalThis.describe("refillMessage", () => {
   });
 });
 
+globalThis.describe("isThrottle", () => {
+  globalThis.test("recognises the wordings a throttled hold actually comes back with", () => {
+    [
+      "Rate exceeded",
+      "TooManyRequestsException: Rate exceeded",
+      "Request throttled, please try again"
+    ].forEach(reason => {
+      globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle(reason)).toBe(true);
+    });
+  });
+  globalThis.test("leaves a permission failure to the IAM advice", () => {
+    globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle("AccessDeniedException: User is not authorized to perform: lambda:PutFunctionConcurrency")).toBe(false);
+    globalThis.expect(ReventlessSeedAws_Quiesce.isThrottle("ResourceNotFoundException: Function not found")).toBe(false);
+  });
+});
+
 globalThis.describe("noQuiesce", () => {
   let set = v => {
     process.env["SEED_RESET_NO_QUIESCE"] = v;