@reventlessdev/reventless-seed-aws 1.0.0-alpha.10

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

@@ -0,0 +1,861 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 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";
+import * as ClientS3 from "@aws-sdk/client-s3";
+import * as Seed$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+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 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";
+import * as ResourceGroupsTaggingApi$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/ResourceGroupsTaggingApi.res.mjs";
+import * as ClientResourceGroupsTaggingApi from "@aws-sdk/client-resource-groups-tagging-api";
+
+function projectName(projectDir) {
+  let path = projectDir + `/Pulumi.yaml`;
+  let raw;
+  try {
+    raw = Nodefs.readFileSync(path, "utf8");
+  } catch (exn) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `could not read ` + path + ` to scope the wipe to this Pulumi project.`,
+      Error: new Error()
+    };
+  }
+  let line = raw.split("\n").find(line => line.trim().startsWith("name:"));
+  if (line !== undefined) {
+    let trimmed = line.trim();
+    return trimmed.slice("name:".length, trimmed.length).trim().replace(/^[\"']|[\"']$/g, "");
+  }
+  throw {
+    RE_EXN_ID: Seed$ReventlessSeed.Failed,
+    _1: `could not find a \`name:\` field in ` + path + `.`,
+    Error: new Error()
+  };
+}
+
+function field(json, key) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return json[key];
+  }
+}
+
+function asString(json) {
+  if (typeof json === "string") {
+    return json;
+  }
+}
+
+function chunk(arr, size) {
+  let out = [];
+  let i = 0;
+  while (i < arr.length) {
+    out.push(arr.slice(i, i + size | 0));
+    i = i + size | 0;
+  };
+  return out;
+}
+
+let nameAllowlist = /^(alpha|dev|pr-.+)$/;
+
+function readStackConfig(projectDir, backend, stack) {
+  let raw;
+  try {
+    raw = ReventlessSeedAws.pulumi(projectDir, backend, [
+      "config",
+      "--json",
+      "--stack",
+      stack
+    ]);
+  } catch (exn) {
+    raw = undefined;
+  }
+  if (raw === undefined) {
+    return {
+      TAG: "Error",
+      _0: `could not read the Pulumi config for stack "` + stack + `" — is pulumi logged in to the right backend, and is the stack deployed?`
+    };
+  }
+  let match;
+  try {
+    match = JSON.parse(raw);
+  } catch (exn$1) {
+    match = undefined;
+  }
+  if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+    return {
+      TAG: "Ok",
+      _0: match
+    };
+  }
+  return {
+    TAG: "Error",
+    _0: `could not parse \`pulumi config --json\` output for stack "` + stack + `".`
+  };
+}
+
+function configValue(cfg, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(cfg[key], v => field(v, "value")), asString);
+}
+
+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 {
+      return "Other";
+    }
+  }
+  let match = arn.split(":table/");
+  if (match.length !== 2) {
+    return "Other";
+  }
+  let name = match[1];
+  return {
+    TAG: "Table",
+    _0: name
+  };
+}
+
+function tagValue(tags, key) {
+  return Stdlib_Array.findMap(tags, t => {
+    if (t.Key === key) {
+      return t.Value;
+    }
+  });
+}
+
+async function discover(region, stack, platform) {
+  let client = ResourceGroupsTaggingApi$AwsSdk.client(region, undefined);
+  let tables = [];
+  let buckets = [];
+  let loop = async token => {
+    let out = await client.send(new ClientResourceGroupsTaggingApi.GetResourcesCommand({
+      TagFilters: [
+        {
+          Key: "reventless:platform",
+          Values: [platform]
+        },
+        {
+          Key: "reventless:environment",
+          Values: [stack]
+        }
+      ],
+      ResourceTypeFilters: [
+        "dynamodb:table",
+        "s3"
+      ],
+      ResourcesPerPage: 100,
+      PaginationToken: token
+    }));
+    Stdlib_Option.getOr(out.ResourceTagMappingList, []).forEach(m => {
+      let tags = Stdlib_Option.getOr(m.Tags, []);
+      let assertTag = (key, expected) => {
+        let v = tagValue(tags, key);
+        if (v !== undefined && v === expected) {
+          return;
+        }
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `refusing: discovered resource ` + m.ResourceARN + ` carries ` + key + `=` + Stdlib_Option.getOr(v, "<none>") + `, not "` + expected + `".`,
+          Error: new Error()
+        };
+      };
+      assertTag("reventless:platform", platform);
+      assertTag("reventless:environment", stack);
+      let name = classify(m.ResourceARN);
+      if (typeof name !== "object") {
+        return;
+      }
+      if (name.TAG === "Table") {
+        tables.push(name._0);
+        return;
+      }
+      buckets.push(name._0);
+    });
+    let t = out.PaginationToken;
+    if (t !== undefined && t !== "") {
+      return await loop(t);
+    }
+  };
+  await loop(undefined);
+  return [
+    tables,
+    buckets
+  ];
+}
+
+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) {
+  let loop = async (start, acc) => {
+    let out = await DynamoDb_DocumentClient$AwsSdk.ScanCommand.send(new LibDynamodb.ScanCommand({
+      TableName: table,
+      ExclusiveStartKey: start,
+      Select: "COUNT"
+    }));
+    let acc$1 = acc + Stdlib_Option.getOr(out.Count, 0) | 0;
+    let k = out.LastEvaluatedKey;
+    if (k !== undefined) {
+      return await loop(k, acc$1);
+    } else {
+      return acc$1;
+    }
+  };
+  return await loop(undefined, 0);
+}
+
+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
+    }));
+    let n = Stdlib_Option.getOr(out.Versions, []).length + Stdlib_Option.getOr(out.DeleteMarkers, []).length | 0;
+    if (Stdlib_Option.getOr(out.IsTruncated, false)) {
+      return await loop(out.NextKeyMarker, out.NextVersionIdMarker, acc + n | 0);
+    } else {
+      return acc + n | 0;
+    }
+  };
+  return await loop(undefined, undefined, 0);
+}
+
+async function sendBatch(table, requests, attempt) {
+  if (requests.length === 0) {
+    return;
+  }
+  if (attempt > 8) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `table ` + table + `: ` + requests.length.toString() + ` item(s) still unprocessed after 8 retries.`,
+      Error: new Error()
+    };
+  }
+  let out = await DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.send(new LibDynamodb.BatchWriteCommand({
+    RequestItems: Object.fromEntries([[
+        table,
+        requests
+      ]])
+  }));
+  let unprocessed = Stdlib_Option.getOr(Stdlib_Option.flatMap(out.UnprocessedItems, d => d[table]), []);
+  if (unprocessed.length !== 0) {
+    return await sendBatch(table, unprocessed, attempt + 1 | 0);
+  }
+}
+
+async function truncateTable(table) {
+  let desc = await DynamoDb_DynamoDb$AwsSdk.DescribeTableCommand.send(new ClientDynamodb.DescribeTableCommand({
+    TableName: table
+  }));
+  let keyAttrs = Stdlib_Option.getOr(Stdlib_Option.flatMap(desc.Table, t => t.KeySchema), []).map(k => k.AttributeName);
+  if (keyAttrs.length === 0) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `could not read a key schema for table ` + table + `.`,
+      Error: new Error()
+    };
+  }
+  let names = keyAttrs.map((name, i) => [
+    `#k` + i.toString(),
+    name
+  ]);
+  let projection = names.map(param => param[0]).join(", ");
+  let loop = async start => {
+    let out = await DynamoDb_DocumentClient$AwsSdk.ScanCommand.send(new LibDynamodb.ScanCommand({
+      TableName: table,
+      ExclusiveStartKey: start,
+      ExpressionAttributeNames: Object.fromEntries(names),
+      ProjectionExpression: projection
+    }));
+    let requests = Stdlib_Option.getOr(out.Items, []).map(item => {
+      let key = Object.fromEntries(Stdlib_Array.filterMap(keyAttrs, attr => Stdlib_Option.map(field(item, attr), v => [
+        attr,
+        v
+      ])));
+      return {
+        DeleteRequest: {
+          Key: key
+        }
+      };
+    });
+    let batches = chunk(requests, DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize);
+    for (let i = 0, i_finish = batches.length; i < i_finish; ++i) {
+      let b = batches[i];
+      if (b !== undefined) {
+        await sendBatch(table, b, 1);
+      }
+    }
+    let k = out.LastEvaluatedKey;
+    if (k !== undefined) {
+      return await loop(k);
+    }
+  };
+  return await loop(undefined);
+}
+
+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
+    }));
+    let ids = Stdlib_Option.getOr(out.Versions, []).concat(Stdlib_Option.getOr(out.DeleteMarkers, [])).map(v => ({
+      Key: v.Key,
+      VersionId: v.VersionId
+    }));
+    if (ids.length !== 0) {
+      let res = await S3$AwsSdk.DeleteObjectsCommand.send(new ClientS3.DeleteObjectsCommand({
+        Bucket: bucket,
+        Delete: {
+          Objects: ids,
+          Quiet: true
+        }
+      }));
+      let errs = res.Errors;
+      if (errs !== undefined && errs.length !== 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `failed to delete ` + errs.length.toString() + ` object(s) from ` + bucket + `: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(errs[0], e => e.Message), "unknown"),
+          Error: new Error()
+        };
+      }
+    }
+    if (Stdlib_Option.getOr(out.IsTruncated, false)) {
+      return await loop(out.NextKeyMarker, out.NextVersionIdMarker);
+    }
+  };
+  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");
+  let labelsOf = ts => ts.map(t => t.label).join(", ");
+  let other = Stdlib_Option.map(Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_SCOPE"), prim => prim.toLowerCase());
+  if (other !== undefined) {
+    switch (other) {
+      case "domain" :
+        return domain;
+      case "all" :
+      case "both" :
+      case "everything" :
+        return targets;
+      case "platform" :
+        return platform;
+      default:
+        let t = targets.find(t => t.label.toLowerCase() === other);
+        if (t !== undefined) {
+          return [t];
+        }
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `SEED_RESET_SCOPE="` + other + `" is not a scope — use domain, platform, everything, or a plugin label (` + labelsOf(domain) + `).`,
+          Error: new Error()
+        };
+    }
+  } else {
+    let options = [];
+    if (domain.length !== 0) {
+      options.push([
+        `domain — ` + labelsOf(domain),
+        domain
+      ]);
+      if (domain.length > 1) {
+        domain.forEach(t => {
+          options.push([
+            t.label,
+            [t]
+          ]);
+        });
+      }
+    }
+    if (platform.length !== 0) {
+      options.push([
+        `platform — ` + labelsOf(platform),
+        platform
+      ]);
+    }
+    if (domain.length !== 0 && platform.length !== 0) {
+      options.push([
+        `everything — ` + labelsOf(targets),
+        targets
+      ]);
+    }
+    return await Seed_Prompt$ReventlessSeed.select("Reset scope:", options, undefined);
+  }
+}
+
+function gateTarget(target, backend, stack) {
+  let c = readStackConfig(target.projectDir, backend, stack);
+  let cfg;
+  if (c.TAG === "Ok") {
+    cfg = c._0;
+  } else {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: c._0,
+      Error: new Error()
+    };
+  }
+  let match = Stdlib_Option.map(configValue(cfg, "reventless:wipeable"), v => v.trim().toLowerCase());
+  let exit = 0;
+  if (match !== "true") {
+    exit = 1;
+  }
+  if (exit === 1) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: target.label + `: stack "` + stack + `" does not declare \`reventless:wipeable: "true"\` in its Pulumi.` + stack + `.yaml — refusing. Add that line only on disposable dev stacks (see the alpha example configs).`,
+      Error: new Error()
+    };
+  }
+  let r = Seed_Prompt$ReventlessSeed.envValue("AWS_REGION");
+  let exit$1 = 0;
+  if (r !== undefined) {
+    if (r !== "") {
+      return r;
+    }
+    exit$1 = 1;
+  } else {
+    exit$1 = 1;
+  }
+  if (exit$1 === 1) {
+    let r$1 = configValue(cfg, "aws:region");
+    let exit$2 = 0;
+    if (r$1 !== undefined) {
+      if (r$1 !== "") {
+        return r$1;
+      }
+      exit$2 = 2;
+    } else {
+      exit$2 = 2;
+    }
+    if (exit$2 === 2) {
+      throw {
+        RE_EXN_ID: Seed$ReventlessSeed.Failed,
+        _1: target.label + `: could not resolve the AWS region — set AWS_REGION or \`aws:region\` in the stack config.`,
+        Error: new Error()
+      };
+    }
+  }
+}
+
+function reportAll(resolvedList, stack, region) {
+  Seed_Runner$ReventlessSeed.heading(`Reset target: stack "` + stack + `" in ` + region);
+  let total = {
+    contents: 0
+  };
+  resolvedList.forEach(r => {
+    console.log("");
+    console.log(`  ` + r.target.label + `  (` + r.platform + `)`);
+    console.log("    DynamoDB tables:");
+    r.tables.forEach((t, i) => {
+      let c = Stdlib_Option.getOr(r.tableCounts[i], 0);
+      total.contents = total.contents + c | 0;
+      console.log(`      ` + c.toString().padStart(8, " ") + `  ` + t);
+    });
+    if (r.tables.length === 0) {
+      console.log("      (none)");
+    }
+    console.log("    S3 buckets:");
+    r.bucketCounts.forEach(param => {
+      let c = param[1];
+      total.contents = total.contents + c | 0;
+      console.log(`      ` + c.toString().padStart(8, " ") + `  ` + param[0]);
+    });
+    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;
+    }
+  });
+  return total.contents;
+}
+
+function run(stack, backend, targets, param) {
+  let go = async () => {
+    try {
+      if (targets.length === 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: "no targets were declared — nothing to reset.",
+          Error: new Error()
+        };
+      }
+      let url = Seed_Prompt$ReventlessSeed.envValue("SEED_PULUMI_BACKEND");
+      let backend$1 = url !== undefined ? url : backend;
+      let baseTarget = Stdlib_Option.getOr(targets.find(t => t.group === "Platform"), targets[0]);
+      let stack$1 = await ReventlessSeedAws.resolveStack(baseTarget.projectDir, backend$1, stack);
+      if (!nameAllowlist.test(stack$1)) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `stack "` + stack$1 + `" is not on the wipe name-allowlist (alpha, dev, pr-*) — refusing.`,
+          Error: new Error()
+        };
+      }
+      let selected = await chooseScope(targets);
+      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 {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `selected targets span more than one region (` + regions.join(", ") + `) — reset them one region at a time.`,
+          Error: new Error()
+        };
+      }
+      process.env["AWS_REGION"] = region;
+      if (selectedStores.length !== 0 && platformTarget !== undefined) {
+        let platformProject = projectName(platformTarget.projectDir);
+        let match$1 = await discover(region, stack$1, platformProject);
+        let platformBuckets = match$1[1];
+        selectedStores.forEach(s => {
+          if (platformBuckets.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$2 = await discover(region, stack$1, platform);
+          let tables = match$2[0].toSorted(Primitive_string.compare);
+          let buckets = match$2[1].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];
+            if (t !== undefined) {
+              tableCounts.push(await countTable(t));
+            }
+          }
+          let bucketCounts = [];
+          for (let j$1 = 0, j_finish$1 = buckets.length; j$1 < j_finish$1; ++j$1) {
+            let b = buckets[j$1];
+            if (b !== undefined) {
+              bucketCounts.push([
+                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 + `/`)
+              ]);
+            }
+          }
+          resolvedList.push({
+            target: target,
+            platform: platform,
+            tables: tables,
+            tableCounts: tableCounts,
+            bucketCounts: bucketCounts,
+            storeCounts: storeCounts
+          });
+        }
+      }
+      let total = reportAll(resolvedList, stack$1, region);
+      if (total === 0) {
+        Seed_Prompt$ReventlessSeed.close();
+        console.log("");
+        console.log(`Nothing to reset — the selected scope already reads empty in ` + region + `.`);
+        process.exit(0);
+      }
+      let interactive = Stdlib_Option.getOr(process.stdin.isTTY, false);
+      let confirmed;
+      if (interactive) {
+        let typed = await Seed_Prompt$ReventlessSeed.ask(`About to permanently empty ` + total.toString() + ` item(s)/object(s) across the selected scope of "` + stack$1 + `". Type the stack name to confirm, or press Enter to keep this a dry run: `);
+        confirmed = typed.trim() === stack$1;
+      } else {
+        confirmed = Primitive_object.equal(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_WIPE_CONFIRM"), stack$1);
+      }
+      Seed_Prompt$ReventlessSeed.close();
+      if (!confirmed) {
+        console.log("");
+        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$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$4 = 0, j_finish$4 = r.bucketCounts.length; j$4 < j_finish$4; ++j$4) {
+            let match$3 = r.bucketCounts[j$4];
+            if (match$3 !== undefined) {
+              let b$1 = match$3[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$4 = r.storeCounts[j$5];
+            if (match$4 !== undefined) {
+              let s$1 = match$4[0];
+              await emptyBucket(s$1.bucketName, s$1.keyPrefix + `/`);
+              console.log(`  emptied ` + s$1.qualified + ` — ` + match$4[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$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) {
+              remaining = remaining + await countTable(t$2) | 0;
+            }
+          }
+          for (let j$7 = 0, j_finish$7 = r$1.bucketCounts.length; j$7 < j_finish$7; ++j$7) {
+            let match$5 = r$1.bucketCounts[j$7];
+            if (match$5 !== undefined) {
+              remaining = remaining + await countBucket(match$5[0], undefined) | 0;
+            }
+          }
+          for (let j$8 = 0, j_finish$8 = r$1.storeCounts.length; j$8 < j_finish$8; ++j$8) {
+            let match$6 = r$1.storeCounts[j$8];
+            if (match$6 !== undefined) {
+              let s$2 = match$6[0];
+              let left = await countBucket(s$2.bucketName, s$2.keyPrefix + `/`);
+              remaining = remaining + left | 0;
+              console.log(`  verified empty: ` + s$2.qualified + ` — ` + left.toString() + ` object(s) remain under ` + (s$2.bucketName + `/` + s$2.keyPrefix + `/`));
+            }
+          }
+        }
+      }
+      if (remaining !== 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: remaining.toString() + ` item(s)/object(s) remain after the wipe — re-run to finish.`,
+          Error: new Error()
+        };
+      }
+      console.log("");
+      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$1 = Primitive_exceptions.internalToException(raw_message);
+      if (message$1.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
+        Seed_Prompt$ReventlessSeed.close();
+        console.error("");
+        console.error(`Reset aborted — ` + message$1._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$1), Stdlib_JsExn.message), "unknown"));
+        process.exit(1);
+      }
+      return;
+    }
+  };
+  go();
+}
+
+let Ddb;
+
+let Rgt;
+
+let S3;
+
+export {
+  Ddb,
+  Rgt,
+  S3,
+  projectName,
+  field,
+  asString,
+  chunk,
+  nameAllowlist,
+  readStackConfig,
+  configValue,
+  classify,
+  tagValue,
+  discover,
+  splitQualified,
+  parseObjectStores,
+  validateStores,
+  countTable,
+  countBucket,
+  sendBatch,
+  truncateTable,
+  emptyBucket,
+  pluginOf,
+  chooseScope,
+  gateTarget,
+  reportAll,
+  run,
+}
+/* node:fs Not a pure module */