@reventlessdev/reventless-seed-aws 1.0.0-alpha.4 → 1.0.0-alpha.40

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

@@ -4,7 +4,9 @@ import * as Nodefs from "node:fs";
 import * as S3$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/S3.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Lambda$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/Lambda.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as ReventlessSeedAws from "./ReventlessSeedAws.res.mjs";
@@ -14,6 +16,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
 import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
 import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+import * as ReventlessSeedAws_Quiesce from "./ReventlessSeedAws_Quiesce.res.mjs";
 import * as Seed_Prompt$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Prompt.res.mjs";
 import * as Seed_Runner$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Runner.res.mjs";
 import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
@@ -109,25 +112,52 @@ function configValue(cfg, key) {
 }
 
 function classify(arn) {
-  if (!arn.startsWith("arn:aws:dynamodb:")) {
-    if (arn.startsWith("arn:aws:s3:::")) {
-      return {
-        TAG: "Bucket",
-        _0: arn.slice("arn:aws:s3:::".length, arn.length)
-      };
-    } else {
+  if (arn.startsWith("arn:aws:dynamodb:")) {
+    let match = arn.split(":table/");
+    if (match.length !== 2) {
       return "Other";
     }
+    let name = match[1];
+    return {
+      TAG: "Table",
+      _0: name
+    };
+  }
+  if (arn.startsWith("arn:aws:s3:::")) {
+    return {
+      TAG: "Bucket",
+      _0: arn.slice("arn:aws:s3:::".length, arn.length)
+    };
   }
-  let match = arn.split(":table/");
-  if (match.length !== 2) {
+  if (!arn.startsWith("arn:aws:lambda:")) {
     return "Other";
   }
-  let name = match[1];
-  return {
-    TAG: "Table",
-    _0: name
-  };
+  let match$1 = arn.split(":function:");
+  if (match$1.length !== 2) {
+    return "Other";
+  }
+  let rest = match$1[1];
+  let match$2 = rest.split(":");
+  let len = match$2.length;
+  if (len >= 3) {
+    return "Other";
+  }
+  switch (len) {
+    case 0 :
+      return "Other";
+    case 1 :
+      let name$1 = match$2[0];
+      return {
+        TAG: "Function",
+        _0: name$1
+      };
+    case 2 :
+      let name$2 = match$2[0];
+      return {
+        TAG: "Function",
+        _0: name$2
+      };
+  }
 }
 
 function tagValue(tags, key) {
@@ -142,6 +172,7 @@ async function discover(region, stack, platform) {
   let client = ResourceGroupsTaggingApi$AwsSdk.client(region, undefined);
   let tables = [];
   let buckets = [];
+  let functions = [];
   let loop = async token => {
     let out = await client.send(new ClientResourceGroupsTaggingApi.GetResourcesCommand({
       TagFilters: [
@@ -156,7 +187,8 @@ async function discover(region, stack, platform) {
       ],
       ResourceTypeFilters: [
         "dynamodb:table",
-        "s3"
+        "s3",
+        "lambda:function"
       ],
       ResourcesPerPage: 100,
       PaginationToken: token
@@ -180,11 +212,17 @@ async function discover(region, stack, platform) {
       if (typeof name !== "object") {
         return;
       }
-      if (name.TAG === "Table") {
-        tables.push(name._0);
-        return;
+      switch (name.TAG) {
+        case "Table" :
+          tables.push(name._0);
+          return;
+        case "Bucket" :
+          buckets.push(name._0);
+          return;
+        case "Function" :
+          functions.push(name._0);
+          return;
       }
-      buckets.push(name._0);
     });
     let t = out.PaginationToken;
     if (t !== undefined && t !== "") {
@@ -192,10 +230,102 @@ async function discover(region, stack, platform) {
     }
   };
   await loop(undefined);
-  return [
-    tables,
-    buckets
-  ];
+  return {
+    tables: tables,
+    buckets: buckets,
+    functions: functions
+  };
+}
+
+function splitQualified(key) {
+  return Stdlib_Option.map(Stdlib_String.indexOfOpt(key, "."), i => [
+    key.slice(0, i),
+    key.slice(i + 1 | 0, key.length)
+  ]);
+}
+
+function parseObjectStores(json) {
+  if (json !== undefined) {
+    if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+      return Stdlib_Array.reduce(Object.entries(json), {
+        TAG: "Ok",
+        _0: []
+      }, (acc, param) => {
+        let entry = param[1];
+        let qualified = param[0];
+        if (acc.TAG !== "Ok") {
+          return acc;
+        }
+        let match = splitQualified(qualified);
+        let match$1 = Stdlib_Option.flatMap(field(entry, "bucketName"), asString);
+        let match$2 = Stdlib_Option.flatMap(field(entry, "keyPrefix"), asString);
+        if (match !== undefined && match$1 !== undefined && match$2 !== undefined) {
+          return {
+            TAG: "Ok",
+            _0: acc._0.concat([{
+                qualified: qualified,
+                plugin: match[0],
+                store: match[1],
+                bucketName: match$1,
+                keyPrefix: match$2
+              }])
+          };
+        }
+        return {
+          TAG: "Error",
+          _0: `the platform stack's \`objectStores\` output has a malformed entry for "` + qualified + `" — expected a {plugin}.{store} key carrying bucketName and keyPrefix.`
+        };
+      });
+    } else {
+      return {
+        TAG: "Error",
+        _0: "the platform stack's `objectStores` output is not an object."
+      };
+    }
+  } else {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+}
+
+function validateStores(stores) {
+  let s = stores.find(s => {
+    if (s.keyPrefix === "") {
+      return true;
+    } else {
+      return s.store.includes("/");
+    }
+  });
+  if (s !== undefined) {
+    return {
+      TAG: "Error",
+      _0: `store "` + s.qualified + `" has an unusable key prefix ("` + s.keyPrefix + `") — a store name may not be empty or contain "/".`
+    };
+  }
+  let message = Stdlib_Array.findMap(stores, a => Stdlib_Array.findMap(stores, b => {
+    if (a.qualified === b.qualified || a.bucketName !== b.bucketName) {
+      return;
+    } else if (a.keyPrefix === b.keyPrefix) {
+      return `stores "` + a.qualified + `" and "` + b.qualified + `" both live at ` + (a.bucketName + `/` + a.keyPrefix + `/ — a prefix-scoped wipe cannot tell their objects `) + `apart. Rename one store, or qualify the \`@storageRef\` annotation if they were meant to be one shared store.`;
+    } else if (b.keyPrefix.startsWith(a.keyPrefix + "/")) {
+      return `store "` + a.qualified + `" (` + a.bucketName + `/` + a.keyPrefix + `/) encloses "` + b.qualified + `" ` + (`(` + b.keyPrefix + `/) — wiping the first would delete the second's objects. Rename one.`);
+    } else {
+      return;
+    }
+  }));
+  if (message !== undefined) {
+    return {
+      TAG: "Error",
+      _0: message
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
 }
 
 async function countTable(table) {
@@ -216,10 +346,11 @@ async function countTable(table) {
   return await loop(undefined, 0);
 }
 
-async function countBucket(bucket) {
+async function countBucket(bucket, prefix) {
   let loop = async (keyMarker, versionMarker, acc) => {
     let out = await S3$AwsSdk.ListObjectVersionsCommand.send(new ClientS3.ListObjectVersionsCommand({
       Bucket: bucket,
+      Prefix: prefix,
       KeyMarker: keyMarker,
       VersionIdMarker: versionMarker
     }));
@@ -306,10 +437,11 @@ async function truncateTable(table) {
   return await loop(undefined);
 }
 
-async function emptyBucket(bucket) {
+async function emptyBucket(bucket, prefix) {
   let loop = async (keyMarker, versionMarker) => {
     let out = await S3$AwsSdk.ListObjectVersionsCommand.send(new ClientS3.ListObjectVersionsCommand({
       Bucket: bucket,
+      Prefix: prefix,
       KeyMarker: keyMarker,
       VersionIdMarker: versionMarker
     }));
@@ -341,6 +473,10 @@ async function emptyBucket(bucket) {
   return await loop(undefined, undefined);
 }
 
+function pluginOf(t) {
+  return Stdlib_Option.getOr(t.plugin, t.label);
+}
+
 async function chooseScope(targets) {
   let domain = targets.filter(t => t.group === "Domain");
   let platform = targets.filter(t => t.group === "Platform");
@@ -395,7 +531,7 @@ async function chooseScope(targets) {
         targets
       ]);
     }
-    return await Seed_Prompt$ReventlessSeed.select("Reset scope:", options, undefined);
+    return await Seed_Prompt$ReventlessSeed.select("Reset scope:", options, undefined, undefined);
   }
 }
 
@@ -454,6 +590,28 @@ function gateTarget(target, backend, stack) {
   }
 }
 
+function noQuiesce() {
+  let match = Stdlib_Option.map(Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_NO_QUIESCE"), v => v.trim().toLowerCase());
+  if (match === undefined) {
+    return false;
+  }
+  switch (match) {
+    case "1" :
+    case "true" :
+    case "yes" :
+      return true;
+    default:
+      return false;
+  }
+}
+
+function refillMessage(refilled, heldCount) {
+  let total = Stdlib_Array.reduce(refilled, 0, (acc, param) => acc + param[1] | 0);
+  let lines = refilled.map(param => `\n      ` + param[1].toString().padStart(8, " ") + `  ` + param[0]).join("");
+  let diagnosis = heldCount > 0 ? `\n\n  The wipe deleted these and something wrote them back. All ` + heldCount.toString() + ` runtime(s) in scope were held at zero concurrency for the whole wipe, so the writer was an invocation already in flight when the hold took effect. Re-running clears it.` : `\n\n  The wipe deleted these and a running runtime wrote them back. The stack was NOT held (SEED_RESET_NO_QUIESCE), so nothing stopped it, and re-running will not help: the writer keeps the state in memory and restores it on every invocation, identical each time. Re-run without SEED_RESET_NO_QUIESCE so the runtimes are held and recycled.`;
+  return total.toString() + ` item(s)/object(s) came back after the wipe:` + lines + diagnosis;
+}
+
 function reportAll(resolvedList, stack, region) {
   Seed_Runner$ReventlessSeed.heading(`Reset target: stack "` + stack + `" in ` + region);
   let total = {
@@ -479,6 +637,15 @@ function reportAll(resolvedList, stack, region) {
     });
     if (r.bucketCounts.length === 0) {
       console.log("      (none)");
+    }
+    if (r.storeCounts.length !== 0) {
+      console.log("    Object stores:");
+      r.storeCounts.forEach(param => {
+        let c = param[1];
+        let s = param[0];
+        total.contents = total.contents + c | 0;
+        console.log(`      ` + c.toString().padStart(8, " ") + `  ` + s.qualified + `   ` + (s.bucketName + `/` + s.keyPrefix + `/`));
+      });
       return;
     }
   });
@@ -507,7 +674,38 @@ function run(stack, backend, targets, param) {
         };
       }
       let selected = await chooseScope(targets);
-      let regions = selected.map(t => gateTarget(t, backend$1, stack$1));
+      let platformTarget = targets.find(t => t.group === "Platform");
+      let allStores;
+      if (platformTarget !== undefined) {
+        let output = ReventlessSeedAws.stackOutputs(platformTarget.projectDir, backend$1, stack$1);
+        let stores = parseObjectStores(field(output, "objectStores"));
+        if (stores.TAG === "Ok") {
+          allStores = stores._0;
+        } else {
+          throw {
+            RE_EXN_ID: Seed$ReventlessSeed.Failed,
+            _1: stores._0,
+            Error: new Error()
+          };
+        }
+      } else {
+        console.log("");
+        console.log("Note: no `platform` target is declared, so declared object stores could not be resolved — any uploaded objects will be left in place.");
+        allStores = [];
+      }
+      let message = validateStores(allStores);
+      if (message.TAG !== "Ok") {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `refusing: ` + message._0,
+          Error: new Error()
+        };
+      }
+      let storeBucketNames = allStores.map(s => s.bucketName);
+      let selectedStores = allStores.filter(s => selected.some(t => pluginOf(t) === s.plugin));
+      let match = selectedStores.length !== 0;
+      let gated = match && platformTarget !== undefined && !selected.some(t => t.projectDir === platformTarget.projectDir) ? selected.concat([platformTarget]) : selected;
+      let regions = gated.map(t => gateTarget(t, backend$1, stack$1));
       let region = regions[0];
       if (regions.some(r => r !== region)) {
         throw {
@@ -517,14 +715,28 @@ function run(stack, backend, targets, param) {
         };
       }
       process.env["AWS_REGION"] = region;
+      if (selectedStores.length !== 0 && platformTarget !== undefined) {
+        let platformProject = projectName(platformTarget.projectDir);
+        let platformFound = await discover(region, stack$1, platformProject);
+        selectedStores.forEach(s => {
+          if (platformFound.buckets.includes(s.bucketName)) {
+            return;
+          }
+          throw {
+            RE_EXN_ID: Seed$ReventlessSeed.Failed,
+            _1: `refusing: store "` + s.qualified + `" names bucket ` + s.bucketName + `, which does not ` + (`carry reventless:platform=` + platformProject + ` + reventless:environment=` + stack$1 + `.`),
+            Error: new Error()
+          };
+        });
+      }
       let resolvedList = [];
       for (let i = 0, i_finish = selected.length; i < i_finish; ++i) {
         let target = selected[i];
         if (target !== undefined) {
           let platform = projectName(target.projectDir);
-          let match = await discover(region, stack$1, platform);
-          let tables = match[0].toSorted(Primitive_string.compare);
-          let buckets = match[1].toSorted(Primitive_string.compare);
+          let found = await discover(region, stack$1, platform);
+          let tables = found.tables.toSorted(Primitive_string.compare);
+          let buckets = found.buckets.filter(b => !storeBucketNames.includes(b)).toSorted(Primitive_string.compare);
           let tableCounts = [];
           for (let j = 0, j_finish = tables.length; j < j_finish; ++j) {
             let t = tables[j];
@@ -538,7 +750,18 @@ function run(stack, backend, targets, param) {
             if (b !== undefined) {
               bucketCounts.push([
                 b,
-                await countBucket(b)
+                await countBucket(b, undefined)
+              ]);
+            }
+          }
+          let stores$1 = selectedStores.filter(s => s.plugin === pluginOf(target));
+          let storeCounts = [];
+          for (let j$2 = 0, j_finish$2 = stores$1.length; j$2 < j_finish$2; ++j$2) {
+            let s = stores$1[j$2];
+            if (s !== undefined) {
+              storeCounts.push([
+                s,
+                await countBucket(s.bucketName, s.keyPrefix + `/`)
               ]);
             }
           }
@@ -547,7 +770,9 @@ function run(stack, backend, targets, param) {
             platform: platform,
             tables: tables,
             tableCounts: tableCounts,
-            bucketCounts: bucketCounts
+            bucketCounts: bucketCounts,
+            storeCounts: storeCounts,
+            functions: found.functions.toSorted(Primitive_string.compare)
           });
         }
       }
@@ -572,49 +797,128 @@ function run(stack, backend, targets, param) {
         console.log(interactive ? "Dry run — nothing was deleted." : `Dry run — nothing was deleted. Set REVENTLESS_WIPE_CONFIRM=` + stack$1 + ` to empty this scope non-interactively.`);
         process.exit(0);
       }
-      for (let i$1 = 0, i_finish$1 = resolvedList.length; i$1 < i_finish$1; ++i$1) {
-        let r = resolvedList[i$1];
-        if (r !== undefined) {
-          Seed_Runner$ReventlessSeed.heading(`Emptying ` + r.target.label + ` …`);
-          for (let j$2 = 0, j_finish$2 = r.tables.length; j$2 < j_finish$2; ++j$2) {
-            let t$1 = r.tables[j$2];
-            if (t$1 !== undefined) {
-              await truncateTable(t$1);
-              console.log(`  truncated ` + t$1);
+      let functionNames = Stdlib_Array.reduce(resolvedList, [], (acc, r) => acc.concat(r.functions.filter(f => !acc.includes(f))));
+      let quiesce = !noQuiesce() && functionNames.length !== 0;
+      let lambdaClient = Lambda$AwsSdk.client(region, undefined);
+      let held = quiesce ? (Seed_Runner$ReventlessSeed.heading(`Holding ` + functionNames.length.toString() + ` runtime(s) at zero concurrency …`), await ReventlessSeedAws_Quiesce.hold(lambdaClient, functionNames)) : (functionNames.length !== 0 ? (console.log(""), console.log("Note: SEED_RESET_NO_QUIESCE is set — the stack's runtimes keep running through the wipe. A runtime that holds state across invocations can write it straight back over an emptied store."), undefined) : undefined, []);
+      let outcome;
+      try {
+        for (let i$1 = 0, i_finish$1 = resolvedList.length; i$1 < i_finish$1; ++i$1) {
+          let r = resolvedList[i$1];
+          if (r !== undefined) {
+            Seed_Runner$ReventlessSeed.heading(`Emptying ` + r.target.label + ` …`);
+            for (let j$3 = 0, j_finish$3 = r.tables.length; j$3 < j_finish$3; ++j$3) {
+              let t$1 = r.tables[j$3];
+              if (t$1 !== undefined) {
+                await truncateTable(t$1);
+                console.log(`  truncated ` + t$1);
+              }
             }
-          }
-          for (let j$3 = 0, j_finish$3 = r.bucketCounts.length; j$3 < j_finish$3; ++j$3) {
-            let match$1 = r.bucketCounts[j$3];
-            if (match$1 !== undefined) {
-              let b$1 = match$1[0];
-              await emptyBucket(b$1);
-              console.log(`  emptied ` + b$1);
+            for (let j$4 = 0, j_finish$4 = r.bucketCounts.length; j$4 < j_finish$4; ++j$4) {
+              let match$1 = r.bucketCounts[j$4];
+              if (match$1 !== undefined) {
+                let b$1 = match$1[0];
+                await emptyBucket(b$1, undefined);
+                console.log(`  emptied ` + b$1);
+              }
+            }
+            for (let j$5 = 0, j_finish$5 = r.storeCounts.length; j$5 < j_finish$5; ++j$5) {
+              let match$2 = r.storeCounts[j$5];
+              if (match$2 !== undefined) {
+                let s$1 = match$2[0];
+                await emptyBucket(s$1.bucketName, s$1.keyPrefix + `/`);
+                console.log(`  emptied ` + s$1.qualified + ` — ` + match$2[1].toString() + ` object(s) removed from ` + (s$1.bucketName + `/` + s$1.keyPrefix + `/`));
+              }
             }
           }
         }
-      }
-      let remaining = 0;
-      for (let i$2 = 0, i_finish$2 = resolvedList.length; i$2 < i_finish$2; ++i$2) {
-        let r$1 = resolvedList[i$2];
-        if (r$1 !== undefined) {
-          for (let j$4 = 0, j_finish$4 = r$1.tables.length; j$4 < j_finish$4; ++j$4) {
-            let t$2 = r$1.tables[j$4];
-            if (t$2 !== undefined) {
-              remaining = remaining + await countTable(t$2) | 0;
+        let refilled = [];
+        for (let i$2 = 0, i_finish$2 = resolvedList.length; i$2 < i_finish$2; ++i$2) {
+          let r$1 = resolvedList[i$2];
+          if (r$1 !== undefined) {
+            for (let j$6 = 0, j_finish$6 = r$1.tables.length; j$6 < j_finish$6; ++j$6) {
+              let t$2 = r$1.tables[j$6];
+              if (t$2 !== undefined) {
+                let left = await countTable(t$2);
+                if (left !== 0) {
+                  refilled.push([
+                    t$2,
+                    left
+                  ]);
+                }
+              }
             }
-          }
-          for (let j$5 = 0, j_finish$5 = r$1.bucketCounts.length; j$5 < j_finish$5; ++j$5) {
-            let match$2 = r$1.bucketCounts[j$5];
-            if (match$2 !== undefined) {
-              remaining = remaining + await countBucket(match$2[0]) | 0;
+            for (let j$7 = 0, j_finish$7 = r$1.bucketCounts.length; j$7 < j_finish$7; ++j$7) {
+              let match$3 = r$1.bucketCounts[j$7];
+              if (match$3 !== undefined) {
+                let b$2 = match$3[0];
+                let left$1 = await countBucket(b$2, undefined);
+                if (left$1 !== 0) {
+                  refilled.push([
+                    b$2,
+                    left$1
+                  ]);
+                }
+              }
+            }
+            for (let j$8 = 0, j_finish$8 = r$1.storeCounts.length; j$8 < j_finish$8; ++j$8) {
+              let match$4 = r$1.storeCounts[j$8];
+              if (match$4 !== undefined) {
+                let s$2 = match$4[0];
+                let left$2 = await countBucket(s$2.bucketName, s$2.keyPrefix + `/`);
+                if (left$2 !== 0) {
+                  refilled.push([
+                    s$2.qualified + ` (` + s$2.bucketName + `/` + s$2.keyPrefix + `/)`,
+                    left$2
+                  ]);
+                }
+                console.log(`  verified empty: ` + s$2.qualified + ` — ` + left$2.toString() + ` object(s) remain under ` + (s$2.bucketName + `/` + s$2.keyPrefix + `/`));
+              }
             }
           }
         }
+        outcome = {
+          TAG: "Ok",
+          _0: refilled
+        };
+      } catch (raw_message) {
+        let message$1 = Primitive_exceptions.internalToException(raw_message);
+        outcome = message$1.RE_EXN_ID === Seed$ReventlessSeed.Failed ? ({
+            TAG: "Error",
+            _0: message$1._1
+          }) : ({
+            TAG: "Error",
+            _0: `the wipe failed: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message$1), Stdlib_JsExn.message), "unknown error")
+          });
       }
-      if (remaining !== 0) {
+      let warnings;
+      if (held.length !== 0) {
+        Seed_Runner$ReventlessSeed.heading(`Recycling ` + held.length.toString() + ` runtime(s) …`);
+        let recycled = await ReventlessSeedAws_Quiesce.recycle(lambdaClient, held);
+        let released = await ReventlessSeedAws_Quiesce.release(lambdaClient, held);
+        warnings = recycled.concat(released);
+      } else {
+        warnings = [];
+      }
+      if (warnings.length !== 0) {
+        console.error("");
+        warnings.forEach(w => {
+          console.error(`  warning: ` + w);
+        });
+      }
+      if (outcome.TAG === "Ok") {
+        let refilled$1 = outcome._0;
+        if (refilled$1.length !== 0) {
+          throw {
+            RE_EXN_ID: Seed$ReventlessSeed.Failed,
+            _1: refillMessage(refilled$1, held.length),
+            Error: new Error()
+          };
+        }
+      } else {
         throw {
           RE_EXN_ID: Seed$ReventlessSeed.Failed,
-          _1: remaining.toString() + ` item(s)/object(s) remain after the wipe — re-run to finish.`,
+          _1: outcome._0,
           Error: new Error()
         };
       }
@@ -622,18 +926,18 @@ function run(stack, backend, targets, param) {
       console.log(`Reset complete — the selected scope of "` + stack$1 + `" reads empty and is re-seedable.`);
       process.exit(0);
       return;
-    } catch (raw_message) {
-      let message = Primitive_exceptions.internalToException(raw_message);
-      if (message.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
+    } catch (raw_message$1) {
+      let message$2 = Primitive_exceptions.internalToException(raw_message$1);
+      if (message$2.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
         Seed_Prompt$ReventlessSeed.close();
         console.error("");
-        console.error(`Reset aborted — ` + message._1);
+        console.error(`Reset aborted — ` + message$2._1);
         process.exit(1);
       } else {
         Seed_Prompt$ReventlessSeed.close();
         console.error("");
         console.error("Reset aborted with an unexpected error:");
-        console.error(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message), Stdlib_JsExn.message), "unknown"));
+        console.error(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message$2), Stdlib_JsExn.message), "unknown"));
         process.exit(1);
       }
       return;
@@ -648,10 +952,16 @@ let Rgt;
 
 let S3;
 
+let Lambda;
+
+let Quiesce;
+
 export {
   Ddb,
   Rgt,
   S3,
+  Lambda,
+  Quiesce,
   projectName,
   field,
   asString,
@@ -662,13 +972,19 @@ export {
   classify,
   tagValue,
   discover,
+  splitQualified,
+  parseObjectStores,
+  validateStores,
   countTable,
   countBucket,
   sendBatch,
   truncateTable,
   emptyBucket,
+  pluginOf,
   chooseScope,
   gateTarget,
+  noQuiesce,
+  refillMessage,
   reportAll,
   run,
 }