@reventlessdev/reventless-aws 3.0.0-alpha.218 → 3.0.0-alpha.219

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.219 (2026-07-21)
+
+### Features
+
+* **aws:** retrying SourceApiAssociation provider for concurrent merged-API deploys ([446a8fe](https://github.com/ReventlessDev/reventless-core/commit/446a8fe77ae9ad94a46eb58ec746f56130974f8e))
+* **core:** populate pluginName + route MCP dispatch through shared helper ([06ec4f9](https://github.com/ReventlessDev/reventless-core/commit/06ec4f98b2dc23a8ef547a754d140e48268ee183))
+
+
 # 3.0.0-alpha.218 (2026-07-20)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.218",
+  "version": "3.0.0-alpha.219",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,15 +9,15 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.24",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.56",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.173",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.29",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.56",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.174",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.102",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.28",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.37",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.29",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.38",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.79"
   },
   "devDependencies": {

package/src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res

@@ -0,0 +1,436 @@
+/** AppSync SourceApiAssociation backed by a Pulumi dynamic provider that
+    retries CreateSourceApiAssociation (and Delete) on the per-merged-API
+    concurrency race:
+
+      ConcurrentModificationException (HTTP 409)
+
+    AWS serializes association writes per merged API. When plugin stacks deploy
+    in parallel, their first-time associations against the *same* merged API
+    race and 409 — the classic `aws:appsync/sourceApiAssociation` provider does
+    NOT retry this, so the losing stack's `pulumi up` fails. This provider owns
+    the Create / Delete / Get SDK calls and retries the 409 (plus sibling
+    transient AWS errors) with capped exponential backoff. It is the Phase-4
+    fix that lets plugin deploys run concurrently again without a CI-level
+    `max-parallel: 1` serialization (docs/plans/done/merged-api-push-free-composition.md,
+    "Association creation 409s under concurrency").
+
+    Steady-state is unaffected: under AUTO_MERGE, AWS re-merges automatically on
+    every source-API schema change with no further association calls, so the
+    409 is a creation/deletion-time race only.
+
+    The initial merge is asynchronous (AUTO_MERGE schedules it); this provider
+    returns as soon as the association record exists. Waiting for MERGE_SUCCESS
+    stays the caller's job via `AppSync_MergedApi.mergeStatusGateWith`, so a
+    failed merge still fails the deploy loudly.
+
+    State migration: aliases the classic
+    `aws:appsync/sourceApiAssociation:SourceApiAssociation` type so existing
+    associations are adopted in-place on first deploy (no delete+recreate → no
+    merge blip on the shared endpoint).
+
+    Mirrors `AppSync_Resolver_Retrying`'s dynImport + hand-rolled-retry shape:
+    Pulumi serialises the dynamic provider's whole captured closure into stack
+    state, and `Effect` (used by the in-process `AppSync_Error` retry) fails
+    that serialisation, so the SDK is lazily imported and the backoff loop is
+    hand-rolled here. */
+
+let log = ReventlessCore.Logger.fromEnv()
+
+// ── AWS SDK bindings (lazily imported — see AppSync_Resolver_Retrying) ─────────
+
+type appSyncClient
+
+type mergeConfig = {mergeType: string}
+
+type createInput = {
+  mergedApiIdentifier: string,
+  sourceApiIdentifier: string,
+  sourceApiAssociationConfig?: mergeConfig,
+}
+
+type assocSummary = {
+  associationId?: string,
+  associationArn?: string,
+}
+type createResult = {sourceApiAssociation?: assocSummary}
+type getResult = {sourceApiAssociation?: assocSummary}
+
+type idInput = {associationId: string, mergedApiIdentifier: string}
+
+type createCmd
+type getCmd
+type deleteCmd
+
+// Shape of the dynamically-imported `@aws-sdk/client-appsync` module. Only the
+// three association commands are needed here.
+type sdkModule = {
+  @as("AppSyncClient") clientCtor: unit => appSyncClient,
+  @as("CreateSourceApiAssociationCommand") createCtor: createInput => createCmd,
+  @as("GetSourceApiAssociationCommand") getCtor: idInput => getCmd,
+  @as("DeleteSourceApiAssociationCommand") deleteCtor: idInput => deleteCmd,
+}
+
+// Calls a constructor with `new` — the SDK exports plain classes.
+let newOf1: ('ctor, 'arg) => 'r = %raw(`(C, x) => new C(x)`)
+let newOf0: 'ctor => 'r = %raw(`(C) => new C()`)
+
+@send external sendCreate: (appSyncClient, createCmd) => promise<createResult> = "send"
+@send external sendGet: (appSyncClient, getCmd) => promise<getResult> = "send"
+@send external sendDelete: (appSyncClient, deleteCmd) => promise<unit> = "send"
+
+// Dynamic ESM import — emitted as a literal `import("...")` so the bundler /
+// Pulumi serialiser does not statically capture the module in the closure.
+@val external dynImport: string => promise<sdkModule> = "import"
+
+let _sdk: ref<option<sdkModule>> = ref(None)
+let _client: ref<option<appSyncClient>> = ref(None)
+
+let getSdk = async (): sdkModule =>
+  switch _sdk.contents {
+  | Some(m) => m
+  | None =>
+    let m = await dynImport("@aws-sdk/client-appsync")
+    _sdk.contents = Some(m)
+    m
+  }
+
+let getClient = async (): appSyncClient =>
+  switch _client.contents {
+  | Some(c) => c
+  | None =>
+    let sdk = await getSdk()
+    let c = newOf0(sdk.clientCtor)
+    _client.contents = Some(c)
+    c
+  }
+
+// ── Error classification ──────────────────────────────────────────────────────
+
+@get @return(nullable) external exnName: JsExn.t => option<string> = "name"
+
+// Transient AWS errors worth retrying — the same set `AppSync_Error.classify`
+// treats as Transient, matched here by exception name OR message (the SDK
+// surfaces the code in either depending on the error path).
+let transientNames = [
+  "ConcurrentModificationException",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "InternalFailureException",
+  "ServiceUnavailableException",
+  "ServiceUnavailable",
+]
+
+/** Returns `true` iff the error is the per-merged-API association concurrency
+    race: `ConcurrentModificationException` (HTTP 409). Exposed for testing. */
+let isConcurrentModificationError = (jsErr: JsExn.t): bool =>
+  switch (jsErr->exnName, JsExn.message(jsErr)) {
+  | (Some("ConcurrentModificationException"), _) => true
+  | (_, Some(msg)) => msg->String.includes("ConcurrentModificationException")
+  | _ => false
+  }
+
+/** Returns `true` for any transient AWS error the create/delete loop should
+    retry (the 409 race plus throttling / transient service errors). */
+let isRetryableAssociationError = (jsErr: JsExn.t): bool =>
+  switch (jsErr->exnName, JsExn.message(jsErr)) {
+  | (Some(name), _) if transientNames->Array.includes(name) => true
+  | (_, Some(msg)) => transientNames->Array.some(n => msg->String.includes(n))
+  | _ => false
+  }
+
+/** Returns `true` iff the target association is already gone, so a delete /
+    read should be treated as a no-op / drift. AWS reports a missing merged API
+    or association as `NotFoundException`. */
+let isAlreadyGoneError = (jsErr: JsExn.t): bool =>
+  switch (jsErr->exnName, JsExn.message(jsErr)) {
+  | (Some("NotFoundException"), _) => true
+  | (_, Some(msg)) => msg->String.includes("NotFoundException") || msg->String.includes("not found")
+  | _ => false
+  }
+
+// ── Retry helper ─────────────────────────────────────────────────────────────
+
+@val external setTimeout: (unit => unit, int) => int = "setTimeout"
+
+/** Throws a JavaScript exception directly (bypasses the ReScript exn wrapper),
+    so Pulumi displays AWS's real message rather than "error: undefined". */
+let jsThrow: JsExn.t => 'a = %raw(`e => { throw e }`)
+
+/** Hand-rolled retry on the transient AppSync association races with capped
+    exponential backoff. Delay starts at 2 s, doubles each attempt, caps at
+    30 s; up to 8 attempts → ~150 s budget — enough to outlast several serial
+    per-merged-API merges (each ~12 s, spike-measured) when a handful of plugin
+    stacks associate against one merged API at once. Beyond that, failing loud
+    beats retrying forever. */
+let rec runWithRetry = async (
+  ~attempt: int=0,
+  ~maxAttempts: int=8,
+  ~delayMs: int=2000,
+  ~maxDelayMs: int=30000,
+  makeCall: unit => promise<'a>,
+): 'a => {
+  try {
+    await makeCall()
+  } catch {
+  | exn =>
+    let jsExn = exn->JsExn.fromException
+    let name = jsExn->Option.flatMap(exnName)->Option.getOr("(no name)")
+    let msg = jsExn->Option.flatMap(JsExn.message)->Option.getOr("(no message)")
+    let isRetryable =
+      attempt < maxAttempts &&
+      jsExn->Option.mapOr(false, isRetryableAssociationError)
+    if isRetryable {
+      log.info(
+        ~comp="AppSync_SourceApiAssociation_Retrying",
+        `attempt ${(attempt + 1)->Int.toString}/${maxAttempts->Int.toString} failed, retrying in ${delayMs->Int.toString}ms: ${name}: ${msg}`,
+      )
+      let _ = await Promise.make((resolve, _) => setTimeout(resolve, delayMs)->ignore)
+      let nextDelay = delayMs * 2
+      let cappedDelay = nextDelay > maxDelayMs ? maxDelayMs : nextDelay
+      await runWithRetry(~attempt=attempt + 1, ~maxAttempts, ~delayMs=cappedDelay, ~maxDelayMs, makeCall)
+    } else {
+      if attempt > 0 {
+        log.warn(
+          ~comp="AppSync_SourceApiAssociation_Retrying",
+          `giving up after ${(attempt + 1)->Int.toString} attempts: ${name}: ${msg}`,
+        )
+      }
+      switch jsExn {
+      | Some(e) => jsThrow(e)
+      | None => throw(exn)
+      }
+    }
+  }
+}
+
+// ── Identifier extraction ─────────────────────────────────────────────────────
+//
+// Pulumi passes OUTPUTS (not inputs) to delete/read handlers, and an adopted
+// classic resource carries a different output shape than this provider writes.
+// The resource `id` is always present, so derive (mergedApiId, associationId)
+// from it, falling back to stored props for older/mixed state.
+//
+//   - this provider's own id  = the association ARN:
+//       arn:aws:appsync:<region>:<acct>:apis/<mergedApiId>/sourceApiAssociations/<assocId>
+//   - the classic provider's id = "<mergedApiId>,<assocId>"
+
+let idsFromArn = (arn: string): option<idInput> => {
+  let parts = arn->String.split("/")
+  let idx = parts->Array.indexOf("sourceApiAssociations")
+  switch (idx >= 1, parts->Array.get(idx - 1), parts->Array.get(idx + 1)) {
+  | (true, Some(mergedApiId), Some(assocId)) =>
+    Some({mergedApiIdentifier: mergedApiId, associationId: assocId})
+  | _ => None
+  }
+}
+
+let idsFromComposite = (id: string): option<idInput> =>
+  switch id->String.split(",") {
+  | [mergedApiId, assocId] => Some({mergedApiIdentifier: mergedApiId, associationId: assocId})
+  | _ => None
+  }
+
+// ── Provider input / output shapes ────────────────────────────────────────────
+
+type providerInputs = {
+  mergedApiIdentifier: string,
+  sourceApiIdentifier: string,
+  mergeType: string,
+}
+
+// `arn` / `associationId` are named to match PulumiAws.AppSync.SourceApiAssociation.t
+// so consumers (mergeStatusGateWith) read `.associationId` unchanged. All fields
+// diff_ compares must live here or `olds.field` is undefined at diff time.
+type createOuts = {
+  arn: string,
+  associationId: string,
+  mergedApiIdentifier: string,
+  sourceApiIdentifier: string,
+  mergeType: string,
+}
+type createResultOut = {id: string, outs: createOuts}
+type updateResultOut = {outs: createOuts}
+type diffResult = {changes: bool, replaces: array<string>, deleteBeforeReplace: bool}
+type readResult = {id?: string, props?: createOuts}
+
+// Extract from stored outs OR classic-shaped props via the id, so delete/read
+// work for both this provider's resources and freshly-adopted classic ones.
+let identifiersFrom = (~id: string, ~props: createOuts): option<idInput> =>
+  switch idsFromArn(id) {
+  | Some(ids) => Some(ids)
+  | None =>
+    switch idsFromComposite(id) {
+    | Some(ids) => Some(ids)
+    | None =>
+      // Last resort: this provider's own stored outs.
+      switch idsFromArn(props.arn) {
+      | Some(ids) => Some(ids)
+      | None => None
+      }
+    }
+  }
+
+// ── Provider methods ──────────────────────────────────────────────────────────
+
+let extractIds = (resp: createResult): (string, string) =>
+  switch resp.sourceApiAssociation {
+  | Some({associationArn: ?Some(arn), associationId: ?Some(aid)}) => (arn, aid)
+  | _ =>
+    JsError.throwWithMessage(
+      "CreateSourceApiAssociation returned no associationArn / associationId",
+    )
+  }
+
+let create = async (inputs: providerInputs): createResultOut => {
+  let sdk = await getSdk()
+  let client = await getClient()
+  let (arn, associationId) = await runWithRetry(() =>
+    client
+    ->sendCreate(
+      newOf1(
+        sdk.createCtor,
+        {
+          mergedApiIdentifier: inputs.mergedApiIdentifier,
+          sourceApiIdentifier: inputs.sourceApiIdentifier,
+          sourceApiAssociationConfig: {mergeType: inputs.mergeType},
+        },
+      ),
+    )
+    ->Promise.thenResolve(extractIds)
+  )
+  {
+    id: arn,
+    outs: {
+      arn,
+      associationId,
+      mergedApiIdentifier: inputs.mergedApiIdentifier,
+      sourceApiIdentifier: inputs.sourceApiIdentifier,
+      mergeType: inputs.mergeType,
+    },
+  }
+}
+
+// No in-place mutation path: identity changes force replace (see diff_), and
+// AUTO_MERGE re-merges are automatic, so update is only ever reached for a
+// no-op reconcile — return the stored outs unchanged.
+let update = async (_id: string, olds: createOuts, _news: providerInputs): updateResultOut => {
+  {outs: olds}
+}
+
+let delete_ = async (id: string, props: createOuts): unit => {
+  let sdk = await getSdk()
+  let client = await getClient()
+  switch identifiersFrom(~id, ~props) {
+  | None =>
+    log.warn(
+      ~comp="AppSync_SourceApiAssociation_Retrying",
+      `delete: could not derive association identifiers from id "${id}"; treating as already gone`,
+    )
+  | Some(ids) =>
+    try {
+      await runWithRetry(() => client->sendDelete(newOf1(sdk.deleteCtor, ids)))
+    } catch {
+    | exn if exn->JsExn.fromException->Option.mapOr(false, isAlreadyGoneError) => ()
+    }
+  }
+}
+
+let isDefined: string => bool = %raw(`x => x !== undefined && x !== null`)
+
+/** Identity fields force replace — AWS cannot re-point an association's merged
+    API or source API in place. Guard undefined olds (adopted classic state)
+    so a missing field never spuriously flags a replace. */
+let diff_ = (_id: string, olds: createOuts, news: providerInputs): diffResult => {
+  let replaces =
+    [
+      isDefined(olds.mergedApiIdentifier) && olds.mergedApiIdentifier != news.mergedApiIdentifier
+        ? Some("mergedApiIdentifier")
+        : None,
+      isDefined(olds.sourceApiIdentifier) && olds.sourceApiIdentifier != news.sourceApiIdentifier
+        ? Some("sourceApiIdentifier")
+        : None,
+      isDefined(olds.mergeType) && olds.mergeType != news.mergeType ? Some("mergeType") : None,
+    ]->Array.filterMap(x => x)
+  // createBeforeDelete: a replace only ever fires on an identity change → a
+  // different (mergedApi, sourceApi) pair, so the new association can be made
+  // before the old is torn down without a duplicate-pair rejection.
+  {changes: replaces->Array.length > 0, replaces, deleteBeforeReplace: false}
+}
+
+/** Read live state for `pulumi refresh`: GetSourceApiAssociation. Missing
+    (association or merged API gone) → return `{}` so Pulumi drops it from state
+    and the next `up` recreates it; other errors propagate so refresh fails
+    loudly rather than silently discarding the resource. */
+let read_ = async (id: string, props: createOuts): readResult => {
+  let sdk = await getSdk()
+  let client = await getClient()
+  switch identifiersFrom(~id, ~props) {
+  | None => ({}: readResult)
+  | Some(ids) =>
+    try {
+      let _ = await client->sendGet(newOf1(sdk.getCtor, ids))
+      {id, props}
+    } catch {
+    | exn if exn->JsExn.fromException->Option.mapOr(false, isAlreadyGoneError) =>
+      log.info(
+        ~comp="AppSync_SourceApiAssociation_Retrying",
+        `association ${ids.associationId} on ${ids.mergedApiIdentifier} missing in AppSync; reporting drift`,
+      )
+      ({}: readResult)
+    | exn =>
+      let jsExn = exn->JsExn.fromException
+      switch jsExn {
+      | Some(e) => jsThrow(e)
+      | None => throw(exn)
+      }
+    }
+  }
+}
+
+// Provider as a plain JS object (no Pulumi Output captures — all state flows
+// through inputs / olds / news).
+let provider = {
+  "create": create,
+  "update": update,
+  "delete": delete_,
+  "diff": diff_,
+  "read": read_,
+}
+
+// ── Pulumi dynamic resource binding ──────────────────────────────────────────
+
+/** Output shape is identical to PulumiAws.AppSync.SourceApiAssociation.t so
+    `AppSync_MergedApi.associateSourceWithMergedArn` and `mergeStatusGateWith`
+    consume `.id` / `.arn` / `.associationId` unchanged. */
+type t = PulumiAws.AppSync.SourceApiAssociation.t
+
+type constructorProps = {
+  mergedApiIdentifier: Pulumi.Input.t<string>,
+  sourceApiIdentifier: Pulumi.Input.t<string>,
+  mergeType: Pulumi.Input.t<string>,
+}
+
+// pulumi.dynamic.Resource constructor: (provider, name, props, opts). Explicit
+// /index.js path because @pulumi/pulumi/dynamic is a directory import not
+// resolvable in ESM mode.
+@module("@pulumi/pulumi/dynamic/index.js") @new
+external _newResource: ('provider, string, 'props, Pulumi.CustomResourceOptions.t) => t = "Resource"
+
+let make = (
+  ~name: string,
+  ~props: constructorProps,
+  ~opts: option<Pulumi.CustomResourceOptions.t>,
+): t => {
+  // Adopt the classic aws resource previously in state in-place (no
+  // delete+recreate → no merge blip on the shared merged endpoint).
+  let migrationAlias = Pulumi.Alias.make(
+    ~type_="aws:appsync/sourceApiAssociation:SourceApiAssociation",
+    ~name,
+    (),
+  )
+  let finalOpts: Pulumi.CustomResourceOptions.t = switch opts {
+  | Some(o) => {...o, aliases: [migrationAlias]}
+  | None => {aliases: [migrationAlias]}
+  }
+  _newResource(provider, name, props, finalOpts)
+}

package/src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res.mjs

@@ -0,0 +1,340 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Alias$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Alias.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_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as IndexJs from "@pulumi/pulumi/dynamic/index.js";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let newOf1 = ((C, x) => new C(x));
+
+let newOf0 = ((C) => new C());
+
+let _sdk = {
+  contents: undefined
+};
+
+let _client = {
+  contents: undefined
+};
+
+async function getSdk() {
+  let m = _sdk.contents;
+  if (m !== undefined) {
+    return m;
+  }
+  let m$1 = await import("@aws-sdk/client-appsync");
+  _sdk.contents = m$1;
+  return m$1;
+}
+
+async function getClient() {
+  let c = _client.contents;
+  if (c !== undefined) {
+    return Primitive_option.valFromOption(c);
+  }
+  let sdk = await getSdk();
+  let c$1 = newOf0(sdk.AppSyncClient);
+  _client.contents = Primitive_option.some(c$1);
+  return c$1;
+}
+
+let transientNames = [
+  "ConcurrentModificationException",
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "InternalFailureException",
+  "ServiceUnavailableException",
+  "ServiceUnavailable"
+];
+
+function isConcurrentModificationError(jsErr) {
+  let match = jsErr.name;
+  let match$1 = Stdlib_JsExn.message(jsErr);
+  if (match == null) {
+    if (match$1 !== undefined) {
+      return match$1.includes("ConcurrentModificationException");
+    } else {
+      return false;
+    }
+  } else if (match === "ConcurrentModificationException") {
+    return true;
+  } else if (match$1 !== undefined) {
+    return match$1.includes("ConcurrentModificationException");
+  } else {
+    return false;
+  }
+}
+
+function isRetryableAssociationError(jsErr) {
+  let match = jsErr.name;
+  let match$1 = Stdlib_JsExn.message(jsErr);
+  if (!(match == null) && transientNames.includes(match)) {
+    return true;
+  }
+  if (match$1 !== undefined) {
+    return transientNames.some(n => match$1.includes(n));
+  } else {
+    return false;
+  }
+}
+
+function isAlreadyGoneError(jsErr) {
+  let match = jsErr.name;
+  let match$1 = Stdlib_JsExn.message(jsErr);
+  if (!(match == null) && match === "NotFoundException") {
+    return true;
+  }
+  if (match$1 !== undefined) {
+    if (match$1.includes("NotFoundException")) {
+      return true;
+    } else {
+      return match$1.includes("not found");
+    }
+  } else {
+    return false;
+  }
+}
+
+let jsThrow = (e => { throw e });
+
+async function runWithRetry(attemptOpt, maxAttemptsOpt, delayMsOpt, maxDelayMsOpt, makeCall) {
+  let attempt = attemptOpt !== undefined ? attemptOpt : 0;
+  let maxAttempts = maxAttemptsOpt !== undefined ? maxAttemptsOpt : 8;
+  let delayMs = delayMsOpt !== undefined ? delayMsOpt : 2000;
+  let maxDelayMs = maxDelayMsOpt !== undefined ? maxDelayMsOpt : 30000;
+  try {
+    return await makeCall();
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let jsExn = Stdlib_JsExn.fromException(exn);
+    let name = Stdlib_Option.getOr(Stdlib_Option.flatMap(jsExn, prim => Primitive_option.fromNullable(prim.name)), "(no name)");
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(jsExn, Stdlib_JsExn.message), "(no message)");
+    let isRetryable = attempt < maxAttempts && Stdlib_Option.mapOr(jsExn, false, isRetryableAssociationError);
+    if (isRetryable) {
+      log.info("AppSync_SourceApiAssociation_Retrying", undefined, `attempt ` + (attempt + 1 | 0).toString() + `/` + maxAttempts.toString() + ` failed, retrying in ` + delayMs.toString() + `ms: ` + name + `: ` + msg);
+      await new Promise((resolve, param) => {
+        setTimeout(resolve, delayMs);
+      });
+      let nextDelay = (delayMs << 1);
+      let cappedDelay = nextDelay > maxDelayMs ? maxDelayMs : nextDelay;
+      return await runWithRetry(attempt + 1 | 0, maxAttempts, cappedDelay, maxDelayMs, makeCall);
+    }
+    if (attempt > 0) {
+      log.warn("AppSync_SourceApiAssociation_Retrying", undefined, `giving up after ` + (attempt + 1 | 0).toString() + ` attempts: ` + name + `: ` + msg);
+    }
+    if (jsExn !== undefined) {
+      return jsThrow(Primitive_option.valFromOption(jsExn));
+    }
+    throw exn;
+  }
+}
+
+function idsFromArn(arn) {
+  let parts = arn.split("/");
+  let idx = parts.indexOf("sourceApiAssociations");
+  let match = idx >= 1;
+  let match$1 = parts[idx - 1 | 0];
+  let match$2 = parts[idx + 1 | 0];
+  if (match && match$1 !== undefined && match$2 !== undefined) {
+    return {
+      associationId: match$2,
+      mergedApiIdentifier: match$1
+    };
+  }
+}
+
+function idsFromComposite(id) {
+  let match = id.split(",");
+  if (match.length !== 2) {
+    return;
+  }
+  let mergedApiId = match[0];
+  let assocId = match[1];
+  return {
+    associationId: assocId,
+    mergedApiIdentifier: mergedApiId
+  };
+}
+
+function identifiersFrom(id, props) {
+  let ids = idsFromArn(id);
+  if (ids !== undefined) {
+    return ids;
+  }
+  let ids$1 = idsFromComposite(id);
+  if (ids$1 !== undefined) {
+    return ids$1;
+  }
+  let ids$2 = idsFromArn(props.arn);
+  if (ids$2 !== undefined) {
+    return ids$2;
+  }
+}
+
+function extractIds(resp) {
+  let match = resp.sourceApiAssociation;
+  if (match === undefined) {
+    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+  }
+  let aid = match.associationId;
+  if (aid === undefined) {
+    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+  }
+  let arn = match.associationArn;
+  if (arn !== undefined) {
+    return [
+      arn,
+      aid
+    ];
+  } else {
+    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+  }
+}
+
+async function create(inputs) {
+  let sdk = await getSdk();
+  let client = await getClient();
+  let match = await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.CreateSourceApiAssociationCommand, {
+    mergedApiIdentifier: inputs.mergedApiIdentifier,
+    sourceApiIdentifier: inputs.sourceApiIdentifier,
+    sourceApiAssociationConfig: {
+      mergeType: inputs.mergeType
+    }
+  })).then(extractIds));
+  let arn = match[0];
+  return {
+    id: arn,
+    outs: {
+      arn: arn,
+      associationId: match[1],
+      mergedApiIdentifier: inputs.mergedApiIdentifier,
+      sourceApiIdentifier: inputs.sourceApiIdentifier,
+      mergeType: inputs.mergeType
+    }
+  };
+}
+
+async function update(_id, olds, _news) {
+  return {
+    outs: olds
+  };
+}
+
+async function delete_(id, props) {
+  let sdk = await getSdk();
+  let client = await getClient();
+  let ids = identifiersFrom(id, props);
+  if (ids === undefined) {
+    return log.warn("AppSync_SourceApiAssociation_Retrying", undefined, `delete: could not derive association identifiers from id "` + id + `"; treating as already gone`);
+  }
+  try {
+    return await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.DeleteSourceApiAssociationCommand, ids)));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (Stdlib_Option.mapOr(Stdlib_JsExn.fromException(exn), false, isAlreadyGoneError)) {
+      return;
+    }
+    throw exn;
+  }
+}
+
+let isDefined = (x => x !== undefined && x !== null);
+
+function diff_(_id, olds, news) {
+  let replaces = Stdlib_Array.filterMap([
+    isDefined(olds.mergedApiIdentifier) && olds.mergedApiIdentifier !== news.mergedApiIdentifier ? "mergedApiIdentifier" : undefined,
+    isDefined(olds.sourceApiIdentifier) && olds.sourceApiIdentifier !== news.sourceApiIdentifier ? "sourceApiIdentifier" : undefined,
+    isDefined(olds.mergeType) && olds.mergeType !== news.mergeType ? "mergeType" : undefined
+  ], x => x);
+  return {
+    changes: replaces.length !== 0,
+    replaces: replaces,
+    deleteBeforeReplace: false
+  };
+}
+
+async function read_(id, props) {
+  let sdk = await getSdk();
+  let client = await getClient();
+  let ids = identifiersFrom(id, props);
+  if (ids === undefined) {
+    return {};
+  }
+  try {
+    await client.send(newOf1(sdk.GetSourceApiAssociationCommand, ids));
+    return {
+      id: id,
+      props: props
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (Stdlib_Option.mapOr(Stdlib_JsExn.fromException(exn), false, isAlreadyGoneError)) {
+      log.info("AppSync_SourceApiAssociation_Retrying", undefined, `association ` + ids.associationId + ` on ` + ids.mergedApiIdentifier + ` missing in AppSync; reporting drift`);
+      return {};
+    }
+    let jsExn = Stdlib_JsExn.fromException(exn);
+    if (jsExn !== undefined) {
+      return jsThrow(Primitive_option.valFromOption(jsExn));
+    }
+    throw exn;
+  }
+}
+
+let provider = {
+  create: create,
+  update: update,
+  delete: delete_,
+  diff: diff_,
+  read: read_
+};
+
+function make(name, props, opts) {
+  let migrationAlias = Alias$Pulumi.make(name, "aws:appsync/sourceApiAssociation:SourceApiAssociation", undefined);
+  let finalOpts;
+  if (opts !== undefined) {
+    let newrecord = {...opts};
+    newrecord.aliases = [migrationAlias];
+    finalOpts = newrecord;
+  } else {
+    finalOpts = {
+      aliases: [migrationAlias]
+    };
+  }
+  return new IndexJs.Resource(provider, name, props, finalOpts);
+}
+
+export {
+  log,
+  newOf1,
+  newOf0,
+  _sdk,
+  _client,
+  getSdk,
+  getClient,
+  transientNames,
+  isConcurrentModificationError,
+  isRetryableAssociationError,
+  isAlreadyGoneError,
+  jsThrow,
+  runWithRetry,
+  idsFromArn,
+  idsFromComposite,
+  identifiersFrom,
+  extractIds,
+  create,
+  update,
+  delete_,
+  isDefined,
+  diff_,
+  read_,
+  provider,
+  make,
+}
+/* log Not a pure module */

package/src/adapter/Mcp/MCP_Lambda.res

@@ -322,14 +322,6 @@ external makeGenerateCommand: (
 external sqsPublishJsons: ('queue, string) => ReventlessCore.CommandGenerator.publishJsons =
   "publishJsons"
 
-@module("@reventlessdev/reventless-core/src/RequestContext.res.mjs")
-external requestContextTag: 'a = "tag"
-
-@module("effect/Effect")
-external effectProvideService: ('a, 'b) => 'c = "provideService"
-
-@send external pipe: ('a, 'b) => 'c = "pipe"
-
 let makeQueueRef: string => 'a = %raw(`(url) => ({ id: url, name: url, arn: "" })`)
 
 // Decode the payload section of a JWT (base64url → JSON) without signature verification.
@@ -384,16 +376,6 @@ let extractIdentity = (authHeader: option<string>): Reventless.Identity.t =>
     }
   }
 
-let runEffect = (correlationId: option<string>, effect) =>
-  effect
-  ->pipe(
-    effectProvideService(
-      requestContextTag,
-      {"correlationId": correlationId->Option.getOr("unknown")},
-    ),
-  )
-  ->pipe(Effect.runPromise)
-
 /** Dispatch an MCP tool call through makeGenerateCommand so the interceptor hook fires.
     The commandTopicArn from mcpConfig tells us which SQS FIFO queue to target. */
 let dispatchTool = async (
@@ -416,7 +398,14 @@ let dispatchTool = async (
     meta: {ip: [], user: identity.userId, info: `mcp/tools/${tool.name}`},
     identity,
   }
-  await runEffect(None, generateCommand(payload))
+  // Route through the shared dispatch helper so this tool call gets the same
+  // correlationId / comp log annotation and a populated RequestContext (identity
+  // included) as every other dispatch boundary.
+  await ReventlessCore.Runtime.runEffect(
+    ~comp=`Mcp(${tool.name})`,
+    ~identity,
+    generateCommand(payload),
+  )
 }
 
 // ─── Deploy-time infrastructure (placeholder) ─────────────────────────────

package/src/adapter/Mcp/MCP_Lambda.res.mjs

@@ -10,13 +10,13 @@ import * as Stream$1 from "effect/Stream";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as AWS$ReventlessAws from "../AWS.res.mjs";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Runtime$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/Runtime.res.mjs";
 import * as AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/AdminApi.res.mjs";
 import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
 import * as MCP_SchemaGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/MCP_SchemaGenerator.res.mjs";
 import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
-import * as RequestContextResMjs from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
 import * as CommandTopicChannel_SQS_RuntimeResMjs from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 import * as CommandGenerator_CallbackResMjs from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
 
@@ -247,12 +247,6 @@ function extractIdentity(authHeader) {
   };
 }
 
-function runEffect(correlationId, effect) {
-  return effect.pipe(Effect.provideService(RequestContextResMjs.tag, {
-    correlationId: Stdlib_Option.getOr(correlationId, "unknown")
-  })).pipe(prim => Effect.runPromise(prim));
-}
-
 async function dispatchTool(tool, args, identity) {
   let queueRef = makeQueueRef(tool.commandTopicArn);
   let publishJsons = CommandTopicChannel_SQS_RuntimeResMjs.publishJsons(queueRef, AWS$ReventlessAws.SQS_FIFO.service);
@@ -269,7 +263,7 @@ async function dispatchTool(tool, args, identity) {
     meta: payload_meta,
     identity: identity
   };
-  return await runEffect(undefined, generateCommand(payload));
+  return await Runtime$ReventlessCore.runEffect(undefined, undefined, `Mcp(` + tool.name + `)`, undefined, identity, undefined, generateCommand(payload));
 }
 
 export {
@@ -283,7 +277,6 @@ export {
   makeQueueRef,
   decodeJwtClaims,
   extractIdentity,
-  runEffect,
   dispatchTool,
 }
 /* S Not a pure module */

package/src/components/Api/AppSync_MergedApi.res

@@ -122,9 +122,11 @@ let make = (~name: string, ~opts: Pulumi.ComponentResource.options): t => {
 
 /** Associate a source API with the merged API under AUTO_MERGE. AWS
     serializes association CREATES per merged API (409
-    ConcurrentModificationException) — the platform stack's own associations
-    are inherently sequential; concurrent first-time plugin-stack deploys need
-    retry-with-backoff (Phase 4). */
+    ConcurrentModificationException). This platform-stack form stays on the
+    classic provider: the platform stack creates all its own associations
+    (admin + base) sequentially within one program, so they never race. The
+    cross-stack race is on the plugin-stack `associateSourceWithMergedArn`
+    path, which uses the retrying provider (Phase 4). */
 let associateSource = (
   ~name: string,
   ~mergedApi: t,
@@ -158,8 +160,15 @@ let associateSource = (
 /** Associate a source API against a merged API referenced by ARN — the
     plugin-stack form, where the merged API is not a resource in this stack
     but the platform's `domainMergedApiArn` / `platformMergedApiArn`
-    StackReference export. Same AUTO_MERGE + create-time 409 caveat as
-    `associateSource`. */
+    StackReference export.
+
+    Concurrent first-time plugin deploys race here: AWS serializes association
+    writes per merged API and 409s (`ConcurrentModificationException`). This
+    goes through `AppSync_SourceApiAssociation_Retrying`, a dynamic provider
+    that retries the 409 with backoff (Phase 4), so plugin stacks can deploy in
+    parallel without a CI-level serialization. The returned resource keeps the
+    `PulumiAws.AppSync.SourceApiAssociation.t` shape, so `mergeStatusGateWith`
+    still waits for MERGE_SUCCESS on `.associationId` unchanged. */
 let associateSourceWithMergedArn = (
   ~name: string,
   ~mergedApiArn: Pulumi.Output.t<string>,
@@ -169,20 +178,14 @@ let associateSourceWithMergedArn = (
   let customOpts: Pulumi.CustomResourceOptions.t = {
     parent: ?opts.parent,
   }
-  AppSync.SourceApiAssociation.make(
+  AppSync_SourceApiAssociation_Retrying.make(
     ~name,
-    ~args={
-      mergedApiArn: mergedApiArn->Pulumi.Output.asInput,
-      sourceApiId: sourceApi
+    ~props={
+      mergedApiIdentifier: mergedApiArn->Pulumi.Output.asInput,
+      sourceApiIdentifier: sourceApi
       ->Pulumi.Output.flatMap((a: AppSync.GraphQLApi.t) => a.id)
       ->Pulumi.Output.asInput,
-      sourceApiAssociationConfigs: [
-        (
-          {
-            mergeType: AppSync.SourceApiAssociation.AUTO_MERGE->Pulumi.Input.make,
-          }: AppSync.SourceApiAssociation.sourceApiAssociationConfig
-        )->Pulumi.Input.make,
-      ]->Pulumi.Input.make,
+      mergeType: "AUTO_MERGE"->Pulumi.Input.make,
     },
     ~opts=Some(customOpts),
   )

package/src/components/Api/AppSync_MergedApi.res.mjs

@@ -7,6 +7,7 @@ import * as Pulumi from "@pulumi/pulumi";
 import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
 import * as Auth_Cognito$ReventlessAws from "../../adapter/Auth/Auth_Cognito.res.mjs";
 import * as AppSync_Adapter$ReventlessAws from "./AppSync_Adapter.res.mjs";
+import * as AppSync_SourceApiAssociation_Retrying$ReventlessAws from "../../adapter/Api/AppSync_SourceApiAssociation_Retrying.res.mjs";
 
 function authenticationTypeName(t) {
   switch (t) {
@@ -89,12 +90,10 @@ function associateSourceWithMergedArn(name, mergedApiArn, sourceApi, opts) {
   let customOpts = {
     parent: customOpts_parent
   };
-  return new (Aws.appsync.SourceApiAssociation)(name, {
-    mergedApiArn: mergedApiArn,
-    sourceApiId: Output$Pulumi.flatMap(sourceApi, a => a.id),
-    sourceApiAssociationConfigs: [{
-        mergeType: "AUTO_MERGE"
-      }]
+  return AppSync_SourceApiAssociation_Retrying$ReventlessAws.make(name, {
+    mergedApiIdentifier: mergedApiArn,
+    sourceApiIdentifier: Output$Pulumi.flatMap(sourceApi, a => a.id),
+    mergeType: "AUTO_MERGE"
   }, customOpts);
 }
 

package/tests/AppSync_SourceApiAssociation_RetryingTest.res

@@ -0,0 +1,112 @@
+open JestGlobals
+
+// Build a plain JS object shaped like a JS Error / SDK exception, cast to
+// JsExn.t so the classifiers can be called without a real throw/catch.
+type testError = {name: string, message: string}
+let mkErr = (~name, ~message): JsExn.t => Obj.magic(({name, message}: testError))
+
+module Assoc = AppSync_SourceApiAssociation_Retrying
+
+describe("AppSync_SourceApiAssociation_Retrying.isConcurrentModificationError", () => {
+  testSync("true for ConcurrentModificationException by name", () => {
+    let err = mkErr(~name="ConcurrentModificationException", ~message="Schema is currently being merged")
+    expect(Assoc.isConcurrentModificationError(err))->toBe(true)
+  })
+
+  testSync("true when the name rides in the message", () => {
+    let err = mkErr(~name="Error", ~message="ConcurrentModificationException: try again")
+    expect(Assoc.isConcurrentModificationError(err))->toBe(true)
+  })
+
+  testSync("false for an unrelated error", () => {
+    let err = mkErr(~name="ValidationException", ~message="bad SDL")
+    expect(Assoc.isConcurrentModificationError(err))->toBe(false)
+  })
+})
+
+describe("AppSync_SourceApiAssociation_Retrying.isRetryableAssociationError", () => {
+  describe("returns true", () => {
+    [
+      "ConcurrentModificationException",
+      "ThrottlingException",
+      "TooManyRequestsException",
+      "InternalFailureException",
+      "ServiceUnavailableException",
+    ]->Array.forEach(name =>
+      testSync(name, () => {
+        expect(Assoc.isRetryableAssociationError(mkErr(~name, ~message="x")))->toBe(true)
+      })
+    )
+  })
+
+  describe("returns false", () => {
+    testSync("permanent ValidationException", () => {
+      expect(
+        Assoc.isRetryableAssociationError(mkErr(~name="ValidationException", ~message="bad input")),
+      )->toBe(false)
+    })
+
+    testSync("NotFoundException (a delete no-op, not a retry)", () => {
+      expect(
+        Assoc.isRetryableAssociationError(
+          mkErr(~name="NotFoundException", ~message="association not found"),
+        ),
+      )->toBe(false)
+    })
+
+    testSync("non-exception value", () => {
+      let notErr: JsExn.t = Obj.magic(42)
+      expect(Assoc.isRetryableAssociationError(notErr))->toBe(false)
+    })
+  })
+})
+
+describe("AppSync_SourceApiAssociation_Retrying.isAlreadyGoneError", () => {
+  testSync("true for NotFoundException", () => {
+    expect(Assoc.isAlreadyGoneError(mkErr(~name="NotFoundException", ~message="gone")))->toBe(true)
+  })
+
+  testSync("true when message says not found", () => {
+    expect(Assoc.isAlreadyGoneError(mkErr(~name="Error", ~message="merged API not found")))->toBe(
+      true,
+    )
+  })
+
+  testSync("false for a transient race (must not be swallowed as gone)", () => {
+    expect(
+      Assoc.isAlreadyGoneError(mkErr(~name="ConcurrentModificationException", ~message="retry")),
+    )->toBe(false)
+  })
+})
+
+describe("AppSync_SourceApiAssociation_Retrying.idsFromArn", () => {
+  testSync("parses mergedApiId + associationId from an association ARN", () => {
+    let arn = "arn:aws:appsync:eu-west-1:123456789012:apis/mgd123/sourceApiAssociations/assoc456"
+    switch Assoc.idsFromArn(arn) {
+    | Some(ids) =>
+      expect(ids.mergedApiIdentifier)->toBe("mgd123")
+      expect(ids.associationId)->toBe("assoc456")
+    | None => fail("expected Some")
+    }
+  })
+
+  testSync("None for an ARN that is not an association", () => {
+    let arn = "arn:aws:appsync:eu-west-1:123456789012:apis/mgd123"
+    expect(Assoc.idsFromArn(arn)->Option.isNone)->toBe(true)
+  })
+})
+
+describe("AppSync_SourceApiAssociation_Retrying.idsFromComposite", () => {
+  testSync("parses the classic '<mergedApiId>,<assocId>' id", () => {
+    switch Assoc.idsFromComposite("mgd123,assoc456") {
+    | Some(ids) =>
+      expect(ids.mergedApiIdentifier)->toBe("mgd123")
+      expect(ids.associationId)->toBe("assoc456")
+    | None => fail("expected Some")
+    }
+  })
+
+  testSync("None for a non-composite string", () => {
+    expect(Assoc.idsFromComposite("just-one-value")->Option.isNone)->toBe(true)
+  })
+})

package/tests/AppSync_SourceApiAssociation_RetryingTest.res.mjs

@@ -0,0 +1,133 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as AppSync_SourceApiAssociation_Retrying$ReventlessAws from "../src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res.mjs";
+
+function mkErr(name, message) {
+  return {
+    name: name,
+    message: message
+  };
+}
+
+globalThis.describe("AppSync_SourceApiAssociation_Retrying.isConcurrentModificationError", () => {
+  globalThis.test("true for ConcurrentModificationException by name", () => {
+    let err = {
+      name: "ConcurrentModificationException",
+      message: "Schema is currently being merged"
+    };
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isConcurrentModificationError(err)).toBe(true);
+  });
+  globalThis.test("true when the name rides in the message", () => {
+    let err = {
+      name: "Error",
+      message: "ConcurrentModificationException: try again"
+    };
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isConcurrentModificationError(err)).toBe(true);
+  });
+  globalThis.test("false for an unrelated error", () => {
+    let err = {
+      name: "ValidationException",
+      message: "bad SDL"
+    };
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isConcurrentModificationError(err)).toBe(false);
+  });
+});
+
+globalThis.describe("AppSync_SourceApiAssociation_Retrying.isRetryableAssociationError", () => {
+  globalThis.describe("returns true", () => {
+    [
+      "ConcurrentModificationException",
+      "ThrottlingException",
+      "TooManyRequestsException",
+      "InternalFailureException",
+      "ServiceUnavailableException"
+    ].forEach(name => {
+      globalThis.test(name, () => {
+        globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isRetryableAssociationError({
+          name: name,
+          message: "x"
+        })).toBe(true);
+      });
+    });
+  });
+  globalThis.describe("returns false", () => {
+    globalThis.test("permanent ValidationException", () => {
+      globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isRetryableAssociationError({
+        name: "ValidationException",
+        message: "bad input"
+      })).toBe(false);
+    });
+    globalThis.test("NotFoundException (a delete no-op, not a retry)", () => {
+      globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isRetryableAssociationError({
+        name: "NotFoundException",
+        message: "association not found"
+      })).toBe(false);
+    });
+    globalThis.test("non-exception value", () => {
+      globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isRetryableAssociationError(42)).toBe(false);
+    });
+  });
+});
+
+globalThis.describe("AppSync_SourceApiAssociation_Retrying.isAlreadyGoneError", () => {
+  globalThis.test("true for NotFoundException", () => {
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isAlreadyGoneError({
+      name: "NotFoundException",
+      message: "gone"
+    })).toBe(true);
+  });
+  globalThis.test("true when message says not found", () => {
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isAlreadyGoneError({
+      name: "Error",
+      message: "merged API not found"
+    })).toBe(true);
+  });
+  globalThis.test("false for a transient race (must not be swallowed as gone)", () => {
+    globalThis.expect(AppSync_SourceApiAssociation_Retrying$ReventlessAws.isAlreadyGoneError({
+      name: "ConcurrentModificationException",
+      message: "retry"
+    })).toBe(false);
+  });
+});
+
+globalThis.describe("AppSync_SourceApiAssociation_Retrying.idsFromArn", () => {
+  globalThis.test("parses mergedApiId + associationId from an association ARN", () => {
+    let ids = AppSync_SourceApiAssociation_Retrying$ReventlessAws.idsFromArn("arn:aws:appsync:eu-west-1:123456789012:apis/mgd123/sourceApiAssociations/assoc456");
+    if (ids !== undefined) {
+      globalThis.expect(ids.mergedApiIdentifier).toBe("mgd123");
+      globalThis.expect(ids.associationId).toBe("assoc456");
+      return;
+    } else {
+      return JestGlobals.fail("expected Some");
+    }
+  });
+  globalThis.test("None for an ARN that is not an association", () => {
+    globalThis.expect(Stdlib_Option.isNone(AppSync_SourceApiAssociation_Retrying$ReventlessAws.idsFromArn("arn:aws:appsync:eu-west-1:123456789012:apis/mgd123"))).toBe(true);
+  });
+});
+
+globalThis.describe("AppSync_SourceApiAssociation_Retrying.idsFromComposite", () => {
+  globalThis.test("parses the classic '<mergedApiId>,<assocId>' id", () => {
+    let ids = AppSync_SourceApiAssociation_Retrying$ReventlessAws.idsFromComposite("mgd123,assoc456");
+    if (ids !== undefined) {
+      globalThis.expect(ids.mergedApiIdentifier).toBe("mgd123");
+      globalThis.expect(ids.associationId).toBe("assoc456");
+      return;
+    } else {
+      return JestGlobals.fail("expected Some");
+    }
+  });
+  globalThis.test("None for a non-composite string", () => {
+    globalThis.expect(Stdlib_Option.isNone(AppSync_SourceApiAssociation_Retrying$ReventlessAws.idsFromComposite("just-one-value"))).toBe(true);
+  });
+});
+
+let Assoc;
+
+export {
+  mkErr,
+  Assoc,
+}
+/*  Not a pure module */