@go-to-k/cdkd 0.74.0 → 0.75.0

package/dist/cli.js

@@ -4374,16 +4374,16 @@ var require_printer = __commonJS({
       },
       // Document
       Document: {
-        leave: (node) => join9(node.definitions, "\n\n")
+        leave: (node) => join11(node.definitions, "\n\n")
       },
       OperationDefinition: {
         leave(node) {
-          const varDefs = hasMultilineItems(node.variableDefinitions) ? wrap("(\n", join9(node.variableDefinitions, "\n"), "\n)") : wrap("(", join9(node.variableDefinitions, ", "), ")");
-          const prefix = wrap("", node.description, "\n") + join9(
+          const varDefs = hasMultilineItems(node.variableDefinitions) ? wrap("(\n", join11(node.variableDefinitions, "\n"), "\n)") : wrap("(", join11(node.variableDefinitions, ", "), ")");
+          const prefix = wrap("", node.description, "\n") + join11(
             [
               node.operation,
-              join9([node.name, varDefs]),
-              join9(node.directives, " ")
+              join11([node.name, varDefs]),
+              join11(node.directives, " ")
             ],
             " "
           );
@@ -4391,7 +4391,7 @@ var require_printer = __commonJS({
         }
       },
       VariableDefinition: {
-        leave: ({ variable, type, defaultValue, directives, description }) => wrap("", description, "\n") + variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join9(directives, " "))
+        leave: ({ variable, type, defaultValue, directives, description }) => wrap("", description, "\n") + variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join11(directives, " "))
       },
       SelectionSet: {
         leave: ({ selections }) => block(selections)
@@ -4399,11 +4399,11 @@ var require_printer = __commonJS({
       Field: {
         leave({ alias, name, arguments: args, directives, selectionSet }) {
           const prefix = wrap("", alias, ": ") + name;
-          let argsLine = prefix + wrap("(", join9(args, ", "), ")");
+          let argsLine = prefix + wrap("(", join11(args, ", "), ")");
           if (argsLine.length > MAX_LINE_LENGTH) {
-            argsLine = prefix + wrap("(\n", indent(join9(args, "\n")), "\n)");
+            argsLine = prefix + wrap("(\n", indent(join11(args, "\n")), "\n)");
           }
-          return join9([argsLine, join9(directives, " "), selectionSet], " ");
+          return join11([argsLine, join11(directives, " "), selectionSet], " ");
         }
       },
       Argument: {
@@ -4411,14 +4411,14 @@ var require_printer = __commonJS({
       },
       // Fragments
       FragmentSpread: {
-        leave: ({ name, directives }) => "..." + name + wrap(" ", join9(directives, " "))
+        leave: ({ name, directives }) => "..." + name + wrap(" ", join11(directives, " "))
       },
       InlineFragment: {
-        leave: ({ typeCondition, directives, selectionSet }) => join9(
+        leave: ({ typeCondition, directives, selectionSet }) => join11(
           [
             "...",
             wrap("on ", typeCondition),
-            join9(directives, " "),
+            join11(directives, " "),
             selectionSet
           ],
           " "
@@ -4434,7 +4434,7 @@ var require_printer = __commonJS({
           description
         }) => wrap("", description, "\n") + // Note: fragment variable definitions are experimental and may be changed
         // or removed in the future.
-        `fragment ${name}${wrap("(", join9(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join9(directives, " "), " ")}` + selectionSet
+        `fragment ${name}${wrap("(", join11(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join11(directives, " "), " ")}` + selectionSet
       },
       // Value
       IntValue: {
@@ -4456,17 +4456,17 @@ var require_printer = __commonJS({
         leave: ({ value }) => value
       },
       ListValue: {
-        leave: ({ values }) => "[" + join9(values, ", ") + "]"
+        leave: ({ values }) => "[" + join11(values, ", ") + "]"
       },
       ObjectValue: {
-        leave: ({ fields }) => "{" + join9(fields, ", ") + "}"
+        leave: ({ fields }) => "{" + join11(fields, ", ") + "}"
       },
       ObjectField: {
         leave: ({ name, value }) => name + ": " + value
       },
       // Directive
       Directive: {
-        leave: ({ name, arguments: args }) => "@" + name + wrap("(", join9(args, ", "), ")")
+        leave: ({ name, arguments: args }) => "@" + name + wrap("(", join11(args, ", "), ")")
       },
       // Type
       NamedType: {
@@ -4480,61 +4480,61 @@ var require_printer = __commonJS({
       },
       // Type System Definitions
       SchemaDefinition: {
-        leave: ({ description, directives, operationTypes }) => wrap("", description, "\n") + join9(["schema", join9(directives, " "), block(operationTypes)], " ")
+        leave: ({ description, directives, operationTypes }) => wrap("", description, "\n") + join11(["schema", join11(directives, " "), block(operationTypes)], " ")
       },
       OperationTypeDefinition: {
         leave: ({ operation, type }) => operation + ": " + type
       },
       ScalarTypeDefinition: {
-        leave: ({ description, name, directives }) => wrap("", description, "\n") + join9(["scalar", name, join9(directives, " ")], " ")
+        leave: ({ description, name, directives }) => wrap("", description, "\n") + join11(["scalar", name, join11(directives, " ")], " ")
       },
       ObjectTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join9(
+        leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join11(
           [
             "type",
             name,
-            wrap("implements ", join9(interfaces, " & ")),
-            join9(directives, " "),
+            wrap("implements ", join11(interfaces, " & ")),
+            join11(directives, " "),
             block(fields)
           ],
           " "
         )
       },
       FieldDefinition: {
-        leave: ({ description, name, arguments: args, type, directives }) => wrap("", description, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join9(args, "\n")), "\n)") : wrap("(", join9(args, ", "), ")")) + ": " + type + wrap(" ", join9(directives, " "))
+        leave: ({ description, name, arguments: args, type, directives }) => wrap("", description, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join11(args, "\n")), "\n)") : wrap("(", join11(args, ", "), ")")) + ": " + type + wrap(" ", join11(directives, " "))
       },
       InputValueDefinition: {
-        leave: ({ description, name, type, defaultValue, directives }) => wrap("", description, "\n") + join9(
-          [name + ": " + type, wrap("= ", defaultValue), join9(directives, " ")],
+        leave: ({ description, name, type, defaultValue, directives }) => wrap("", description, "\n") + join11(
+          [name + ": " + type, wrap("= ", defaultValue), join11(directives, " ")],
           " "
         )
       },
       InterfaceTypeDefinition: {
-        leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join9(
+        leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join11(
           [
             "interface",
             name,
-            wrap("implements ", join9(interfaces, " & ")),
-            join9(directives, " "),
+            wrap("implements ", join11(interfaces, " & ")),
+            join11(directives, " "),
             block(fields)
           ],
           " "
         )
       },
       UnionTypeDefinition: {
-        leave: ({ description, name, directives, types }) => wrap("", description, "\n") + join9(
-          ["union", name, join9(directives, " "), wrap("= ", join9(types, " | "))],
+        leave: ({ description, name, directives, types }) => wrap("", description, "\n") + join11(
+          ["union", name, join11(directives, " "), wrap("= ", join11(types, " | "))],
           " "
         )
       },
       EnumTypeDefinition: {
-        leave: ({ description, name, directives, values }) => wrap("", description, "\n") + join9(["enum", name, join9(directives, " "), block(values)], " ")
+        leave: ({ description, name, directives, values }) => wrap("", description, "\n") + join11(["enum", name, join11(directives, " "), block(values)], " ")
       },
       EnumValueDefinition: {
-        leave: ({ description, name, directives }) => wrap("", description, "\n") + join9([name, join9(directives, " ")], " ")
+        leave: ({ description, name, directives }) => wrap("", description, "\n") + join11([name, join11(directives, " ")], " ")
       },
       InputObjectTypeDefinition: {
-        leave: ({ description, name, directives, fields }) => wrap("", description, "\n") + join9(["input", name, join9(directives, " "), block(fields)], " ")
+        leave: ({ description, name, directives, fields }) => wrap("", description, "\n") + join11(["input", name, join11(directives, " "), block(fields)], " ")
       },
       DirectiveDefinition: {
         leave: ({
@@ -4544,84 +4544,84 @@ var require_printer = __commonJS({
           directives,
           repeatable,
           locations
-        }) => wrap("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join9(args, "\n")), "\n)") : wrap("(", join9(args, ", "), ")")) + wrap(" ", join9(directives, " ")) + (repeatable ? " repeatable" : "") + " on " + join9(locations, " | ")
+        }) => wrap("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join11(args, "\n")), "\n)") : wrap("(", join11(args, ", "), ")")) + wrap(" ", join11(directives, " ")) + (repeatable ? " repeatable" : "") + " on " + join11(locations, " | ")
       },
       SchemaExtension: {
-        leave: ({ directives, operationTypes }) => join9(
-          ["extend schema", join9(directives, " "), block(operationTypes)],
+        leave: ({ directives, operationTypes }) => join11(
+          ["extend schema", join11(directives, " "), block(operationTypes)],
           " "
         )
       },
       ScalarTypeExtension: {
-        leave: ({ name, directives }) => join9(["extend scalar", name, join9(directives, " ")], " ")
+        leave: ({ name, directives }) => join11(["extend scalar", name, join11(directives, " ")], " ")
       },
       ObjectTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join9(
+        leave: ({ name, interfaces, directives, fields }) => join11(
           [
             "extend type",
             name,
-            wrap("implements ", join9(interfaces, " & ")),
-            join9(directives, " "),
+            wrap("implements ", join11(interfaces, " & ")),
+            join11(directives, " "),
             block(fields)
           ],
           " "
         )
       },
       InterfaceTypeExtension: {
-        leave: ({ name, interfaces, directives, fields }) => join9(
+        leave: ({ name, interfaces, directives, fields }) => join11(
           [
             "extend interface",
             name,
-            wrap("implements ", join9(interfaces, " & ")),
-            join9(directives, " "),
+            wrap("implements ", join11(interfaces, " & ")),
+            join11(directives, " "),
             block(fields)
           ],
           " "
         )
       },
       UnionTypeExtension: {
-        leave: ({ name, directives, types }) => join9(
+        leave: ({ name, directives, types }) => join11(
           [
             "extend union",
             name,
-            join9(directives, " "),
-            wrap("= ", join9(types, " | "))
+            join11(directives, " "),
+            wrap("= ", join11(types, " | "))
           ],
           " "
         )
       },
       EnumTypeExtension: {
-        leave: ({ name, directives, values }) => join9(["extend enum", name, join9(directives, " "), block(values)], " ")
+        leave: ({ name, directives, values }) => join11(["extend enum", name, join11(directives, " "), block(values)], " ")
       },
       InputObjectTypeExtension: {
-        leave: ({ name, directives, fields }) => join9(["extend input", name, join9(directives, " "), block(fields)], " ")
+        leave: ({ name, directives, fields }) => join11(["extend input", name, join11(directives, " "), block(fields)], " ")
       },
       DirectiveExtension: {
-        leave: ({ name, directives }) => join9(["extend directive @" + name, join9(directives, " ")], " ")
+        leave: ({ name, directives }) => join11(["extend directive @" + name, join11(directives, " ")], " ")
       },
       // Schema Coordinates
       TypeCoordinate: {
         leave: ({ name }) => name
       },
       MemberCoordinate: {
-        leave: ({ name, memberName }) => join9([name, wrap(".", memberName)])
+        leave: ({ name, memberName }) => join11([name, wrap(".", memberName)])
       },
       ArgumentCoordinate: {
-        leave: ({ name, fieldName, argumentName }) => join9([name, wrap(".", fieldName), wrap("(", argumentName, ":)")])
+        leave: ({ name, fieldName, argumentName }) => join11([name, wrap(".", fieldName), wrap("(", argumentName, ":)")])
       },
       DirectiveCoordinate: {
-        leave: ({ name }) => join9(["@", name])
+        leave: ({ name }) => join11(["@", name])
       },
       DirectiveArgumentCoordinate: {
-        leave: ({ name, argumentName }) => join9(["@", name, wrap("(", argumentName, ":)")])
+        leave: ({ name, argumentName }) => join11(["@", name, wrap("(", argumentName, ":)")])
       }
     };
-    function join9(maybeArray, separator = "") {
+    function join11(maybeArray, separator = "") {
       var _maybeArray$filter$jo;
       return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : "";
     }
     function block(array) {
-      return wrap("{\n", indent(join9(array, "\n")), "\n}");
+      return wrap("{\n", indent(join11(array, "\n")), "\n}");
     }
     function wrap(start, maybeString, end = "") {
       return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
@@ -12448,7 +12448,7 @@ var require_graphql = __commonJS({
     var _validate2 = require_validate2();
     var _execute = require_execute();
     function graphql(args) {
-      return new Promise((resolve6) => resolve6(graphqlImpl(args)));
+      return new Promise((resolve8) => resolve8(graphqlImpl(args)));
     }
     function graphqlSync(args) {
       const result = graphqlImpl(args);
@@ -18869,7 +18869,7 @@ var IntrinsicFunctionResolver = class {
               this.logger.debug(
                 `VPC ${physicalId} IPv6 CIDR still associating (attempt ${attempt}/${maxAttempts}), waiting...`
               );
-              await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+              await new Promise((resolve8) => setTimeout(resolve8, 2e3));
             }
             this.logger.warn(
               `VPC ${physicalId} IPv6 CIDR did not reach 'associated' state after ${maxAttempts} attempts`
@@ -19754,7 +19754,7 @@ var DagExecutor = class {
   async execute(concurrency, fn, cancelled = () => false) {
     let active = 0;
     const errors = [];
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const dispatch = () => {
         let changed = true;
         while (changed) {
@@ -19816,7 +19816,7 @@ var DagExecutor = class {
             );
             return;
           }
-          resolve6();
+          resolve8();
         }
       };
       dispatch();
@@ -20497,7 +20497,7 @@ Error: ${err.message || "Unknown error"}`,
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Check if a resource type is supported by Cloud Control API
@@ -21231,7 +21231,7 @@ var CustomResourceProvider = class _CustomResourceProvider {
     return result;
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Adopt an existing custom resource into cdkd state.
@@ -21661,7 +21661,7 @@ function isRetryableTransientError(error, message) {
 }
 
 // src/deployment/retry.ts
-var defaultSleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+var defaultSleep = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
 async function withRetry(operation, logicalId, opts = {}) {
   const maxRetries = opts.maxRetries ?? 8;
   const initialDelayMs = opts.initialDelayMs ?? 1e3;
@@ -21716,7 +21716,7 @@ function validateOptions(opts) {
 async function withResourceDeadline(operation, opts) {
   validateOptions(opts);
   const startedAt = Date.now();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     let settled = false;
     let warnTimer;
     let timeoutTimer;
@@ -21756,7 +21756,7 @@ async function withResourceDeadline(operation, opts) {
           return;
         settled = true;
         cleanup();
-        resolve6(value);
+        resolve8(value);
       },
       (err) => {
         if (settled)
@@ -23791,7 +23791,7 @@ var AppExecutor = class {
    * Spawn subprocess and wait for completion
    */
   spawn(commandLine, env) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const proc = spawn(commandLine, {
         stdio: ["ignore", "pipe", "pipe"],
         shell: true,
@@ -23817,7 +23817,7 @@ var AppExecutor = class {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve6();
+          resolve8();
         } else {
           const stderr = stderrChunks.join("\n");
           reject(
@@ -25323,14 +25323,14 @@ var FileAssetPublisher = class {
    * Upload a single file to S3
    */
   async uploadFile(client, filePath, bucket, key) {
-    const stat = statSync2(filePath);
+    const stat4 = statSync2(filePath);
     const stream = createReadStream(filePath);
     await client.send(
       new PutObjectCommand2({
         Bucket: bucket,
         Key: key,
         Body: stream,
-        ContentLength: stat.size
+        ContentLength: stat4.size
       })
     );
   }
@@ -25339,14 +25339,14 @@ var FileAssetPublisher = class {
    */
   async uploadZip(client, dirPath, bucket, key) {
     const archiver = await import("archiver");
-    const body = await new Promise((resolve6, reject) => {
+    const body = await new Promise((resolve8, reject) => {
       const chunks = [];
       const archive = archiver.default("zip", { zlib: { level: 9 } });
       archive.on("data", (chunk) => chunks.push(chunk));
-      archive.on("end", () => resolve6(Buffer.concat(chunks)));
+      archive.on("end", () => resolve8(Buffer.concat(chunks)));
       archive.on("error", reject);
-      const stat = statSync2(dirPath);
-      if (stat.isDirectory()) {
+      const stat4 = statSync2(dirPath);
+      if (stat4.isDirectory()) {
         archive.directory(dirPath, false);
       } else {
         archive.file(dirPath, { name: basename(dirPath) });
@@ -25528,7 +25528,7 @@ var DockerAssetPublisher = class {
     const token = Buffer.from(authData.authorizationToken, "base64").toString();
     const [username, password] = token.split(":");
     const endpoint = authData.proxyEndpoint || `https://${accountId}.dkr.ecr.${region}.amazonaws.com`;
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve8, reject) => {
       const proc = spawn2(
         "docker",
         ["login", "--username", username, "--password-stdin", endpoint],
@@ -25542,7 +25542,7 @@ var DockerAssetPublisher = class {
       });
       proc.on("close", (code) => {
         if (code === 0) {
-          resolve6();
+          resolve8();
         } else {
           reject(new AssetError(`ECR login failed: ${stderr.trim()}`));
         }
@@ -25595,7 +25595,7 @@ var WorkGraph = class {
   async execute(concurrency, fn) {
     const active = { "asset-build": 0, "asset-publish": 0, stack: 0 };
     const errors = [];
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve8, reject) => {
       const dispatch = () => {
         const ready = [];
         for (const node of this.nodes.values()) {
@@ -25667,7 +25667,7 @@ ${msg}`
             );
             return;
           }
-          resolve6();
+          resolve8();
         }
       };
       dispatch();
@@ -26658,7 +26658,7 @@ var LockManager = class {
           this.logger.info(
             `Stack '${stackName}' (${region}) is locked by ${lockInfo2.owner}${lockInfo2.operation ? ` (operation: ${lockInfo2.operation})` : ""}. Lock expires in ${this.formatDuration(remainingMs)}. Retrying in ${this.formatDuration(retryDelay)}... (attempt ${attempt + 1}/${maxRetries})`
           );
-          await new Promise((resolve6) => setTimeout(resolve6, retryDelay));
+          await new Promise((resolve8) => setTimeout(resolve8, retryDelay));
           continue;
         }
       }
@@ -28356,8 +28356,8 @@ var IAMRoleProvider = class {
       const statePolicies = properties?.["Policies"] ?? [];
       const remaining = new Set(bodies.keys());
       const inline = [];
-      for (const sp of statePolicies) {
-        const name = sp?.PolicyName;
+      for (const sp3 of statePolicies) {
+        const name = sp3?.PolicyName;
         if (typeof name !== "string")
           continue;
         if (bodies.has(name)) {
@@ -30439,8 +30439,8 @@ var IAMUserGroupProvider = class {
     );
     const remaining = new Set(bodies.keys());
     const inline = [];
-    for (const sp of statePolicies) {
-      const name = sp?.PolicyName;
+    for (const sp3 of statePolicies) {
+      const name = sp3?.PolicyName;
       if (typeof name !== "string")
         continue;
       if (bodies.has(name)) {
@@ -30703,7 +30703,7 @@ var S3BucketProvider = class {
    * are equal, we skip the call entirely.
    */
   async applyTagDiff(bucketName, oldTagsRaw, newTagsRaw) {
-    const normalize = (tags) => {
+    const normalize2 = (tags) => {
       const out = [];
       for (const t of tags ?? []) {
         if (t.Key !== void 0 && t.Value !== void 0)
@@ -30711,8 +30711,8 @@ var S3BucketProvider = class {
       }
       return out;
     };
-    const oldNorm = normalize(oldTagsRaw);
-    const newNorm = normalize(newTagsRaw);
+    const oldNorm = normalize2(oldTagsRaw);
+    const newNorm = normalize2(newTagsRaw);
     if (JSON.stringify(oldNorm) === JSON.stringify(newNorm))
       return;
     if (newNorm.length === 0) {
@@ -35152,7 +35152,7 @@ var LambdaFunctionProvider = class {
     return enis;
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Build Lambda Code parameter from CDK properties
@@ -37029,7 +37029,7 @@ var DynamoDBTableProvider = class {
       if (status !== "CREATING") {
         throw new Error(`Unexpected table status: ${status}`);
       }
-      await new Promise((resolve6) => setTimeout(resolve6, 1e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     }
     throw new Error(`Table ${tableName} did not reach ACTIVE status within ${maxAttempts} seconds`);
   }
@@ -37049,7 +37049,7 @@ var DynamoDBTableProvider = class {
       if (status === "ACTIVE") {
         return;
       }
-      await new Promise((resolve6) => setTimeout(resolve6, 1e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     }
     throw new Error(
       `Table ${tableName} did not reach ACTIVE status within ${maxAttempts} seconds after UpdateTable`
@@ -38021,17 +38021,17 @@ var CloudWatchAlarmProvider = class {
         if (m["Period"] !== void 0)
           entry["Period"] = m["Period"];
         if (m["MetricStat"] !== void 0) {
-          const stat = m["MetricStat"];
-          const metric = stat["Metric"];
+          const stat4 = m["MetricStat"];
+          const metric = stat4["Metric"];
           entry["MetricStat"] = {
             Metric: {
               MetricName: metric["MetricName"],
               Namespace: metric["Namespace"],
               Dimensions: metric["Dimensions"]
             },
-            Period: stat["Period"],
-            Stat: stat["Stat"],
-            Unit: stat["Unit"]
+            Period: stat4["Period"],
+            Stat: stat4["Stat"],
+            Unit: stat4["Unit"]
           };
         }
         return entry;
@@ -40229,7 +40229,7 @@ var EC2Provider = class {
           this.logger.debug(
             `VPC ${physicalId} has dependencies (attempt ${attempt}/${maxAttempts}), retrying in ${attempt * 5}s...`
           );
-          await new Promise((resolve6) => setTimeout(resolve6, attempt * 5e3));
+          await new Promise((resolve8) => setTimeout(resolve8, attempt * 5e3));
           continue;
         }
         const cause = error instanceof Error ? error : void 0;
@@ -40393,7 +40393,7 @@ var EC2Provider = class {
           this.logger.debug(
             `Subnet ${physicalId} has dependencies (attempt ${attempt}/${maxAttempts}), retrying in ${attempt * 5}s...`
           );
-          await new Promise((resolve6) => setTimeout(resolve6, attempt * 5e3));
+          await new Promise((resolve8) => setTimeout(resolve8, attempt * 5e3));
           continue;
         }
         const cause = error instanceof Error ? error : void 0;
@@ -41151,7 +41151,7 @@ var EC2Provider = class {
           this.logger.debug(
             `SecurityGroup ${physicalId} has dependent objects (attempt ${attempt}/${maxAttempts}), retrying in ${attempt * 5}s...`
           );
-          await new Promise((resolve6) => setTimeout(resolve6, attempt * 5e3));
+          await new Promise((resolve8) => setTimeout(resolve8, attempt * 5e3));
           continue;
         }
         const cause = error instanceof Error ? error : void 0;
@@ -42095,7 +42095,7 @@ var EC2Provider = class {
    * `setTimeout` globally.
    */
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Check if an error indicates the resource was not found
@@ -42896,17 +42896,17 @@ function flattenIpPermissions(perms, direction) {
         rule["Description"] = grp.Description;
       out.push(rule);
     }
-    for (const pl of p.PrefixListIds ?? []) {
+    for (const pl2 of p.PrefixListIds ?? []) {
       const rule = { ...base };
       if (direction === "ingress") {
-        if (pl.PrefixListId !== void 0)
-          rule["SourcePrefixListId"] = pl.PrefixListId;
+        if (pl2.PrefixListId !== void 0)
+          rule["SourcePrefixListId"] = pl2.PrefixListId;
       } else {
-        if (pl.PrefixListId !== void 0)
-          rule["DestinationPrefixListId"] = pl.PrefixListId;
+        if (pl2.PrefixListId !== void 0)
+          rule["DestinationPrefixListId"] = pl2.PrefixListId;
       }
-      if (pl.Description !== void 0)
-        rule["Description"] = pl.Description;
+      if (pl2.Description !== void 0)
+        rule["Description"] = pl2.Description;
       out.push(rule);
     }
     if ((p.IpRanges?.length ?? 0) === 0 && (p.Ipv6Ranges?.length ?? 0) === 0 && (p.UserIdGroupPairs?.length ?? 0) === 0 && (p.PrefixListIds?.length ?? 0) === 0) {
@@ -44195,7 +44195,7 @@ var ApiGatewayProvider = class _ApiGatewayProvider {
    * Sleep for specified milliseconds
    */
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Convert CloudFormation Tags (Array<{Key, Value}>) to SDK tags (Record<string, string>).
@@ -44850,8 +44850,8 @@ var ApiGatewayV2Provider = class {
   async createRoute(logicalId, resourceType, properties) {
     this.logger.debug(`Creating API Gateway V2 Route ${logicalId}`);
     const apiId = properties["ApiId"];
-    const routeKey = properties["RouteKey"];
-    if (!apiId || !routeKey) {
+    const routeKey2 = properties["RouteKey"];
+    if (!apiId || !routeKey2) {
       throw new ProvisioningError(
         `ApiId and RouteKey are required for API Gateway V2 Route ${logicalId}`,
         resourceType,
@@ -44862,7 +44862,7 @@ var ApiGatewayV2Provider = class {
       const response = await this.getClient().send(
         new CreateRouteCommand2({
           ApiId: apiId,
-          RouteKey: routeKey,
+          RouteKey: routeKey2,
           Target: properties["Target"],
           AuthorizationType: properties["AuthorizationType"],
           AuthorizerId: properties["AuthorizerId"]
@@ -46087,7 +46087,7 @@ var CloudFrontDistributionProvider = class {
         );
         const sleepEnd = Date.now() + delay2;
         while (Date.now() < sleepEnd && !interrupted) {
-          await new Promise((resolve6) => setTimeout(resolve6, 1e3));
+          await new Promise((resolve8) => setTimeout(resolve8, 1e3));
         }
         delay2 = Math.min(delay2 * 1.5, maxDelay);
       }
@@ -49899,7 +49899,7 @@ var RDSProvider = class {
     throw new Error(`Timed out waiting for DBInstance ${dbInstanceIdentifier} to be deleted`);
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Adopt an existing RDS resource into cdkd state.
@@ -50884,7 +50884,7 @@ var DocDBProvider = class {
     throw new Error(`Timed out waiting for DocDB DBInstance ${dbInstanceIdentifier} to be deleted`);
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Adopt an existing DocDB resource into cdkd state.
@@ -51874,7 +51874,7 @@ var NeptuneProvider = class {
     );
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Adopt an existing Neptune resource into cdkd state.
@@ -54414,7 +54414,7 @@ var ElastiCacheProvider = class {
     throw new Error(`Timed out waiting for CacheCluster ${cacheClusterId} to be deleted`);
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   /**
    * Read the AWS-current ElastiCache resource configuration in CFn-property shape.
@@ -55129,7 +55129,7 @@ var ServiceDiscoveryProvider = class {
           logicalId
         );
       }
-      await new Promise((resolve6) => setTimeout(resolve6, delay2));
+      await new Promise((resolve8) => setTimeout(resolve8, delay2));
       delay2 = Math.min(delay2 * 2, 1e4);
     }
     throw new ProvisioningError(
@@ -59654,7 +59654,7 @@ var KinesisStreamProvider = class {
       if (status !== "CREATING" && status !== "UPDATING") {
         throw new Error(`Unexpected stream status: ${status}`);
       }
-      await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 2e3));
     }
     throw new Error(
       `Stream ${streamName} did not reach ACTIVE status within ${maxAttempts * 2} seconds`
@@ -59987,7 +59987,7 @@ var KinesisStreamConsumerProvider = class {
       if (status !== "CREATING") {
         throw new Error(`Unexpected consumer status: ${status}`);
       }
-      await new Promise((resolve6) => setTimeout(resolve6, 1e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     }
     throw new Error(
       `Consumer ${consumerArn} did not reach ACTIVE status within ${maxAttempts} seconds`
@@ -60292,7 +60292,7 @@ var EFSProvider = class {
       this.logger.debug(
         `FileSystem ${fileSystemId} state: ${fs?.LifeCycleState ?? "unknown"}, waiting...`
       );
-      await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
+      await new Promise((resolve8) => setTimeout(resolve8, pollIntervalMs));
     }
     throw new ProvisioningError(
       `Timed out waiting for EFS FileSystem ${fileSystemId} to become available (60s)`,
@@ -60370,7 +60370,7 @@ var EFSProvider = class {
       this.logger.debug(
         `MountTarget ${mountTargetId} state: ${mountTarget?.LifeCycleState ?? "unknown"}, waiting...`
       );
-      await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
+      await new Promise((resolve8) => setTimeout(resolve8, pollIntervalMs));
     }
     throw new ProvisioningError(
       `Timed out waiting for EFS MountTarget ${mountTargetId} to become available (120s)`,
@@ -60436,7 +60436,7 @@ var EFSProvider = class {
         }
         throw error;
       }
-      await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
+      await new Promise((resolve8) => setTimeout(resolve8, pollIntervalMs));
     }
     this.logger.warn(
       `Timed out waiting for EFS MountTarget ${mountTargetId} deletion for ${logicalId} (120s)`
@@ -61394,7 +61394,7 @@ var FirehoseProvider = class {
       this.logger.debug(
         `Firehose ${logicalId} status: ${status} (attempt ${attempt}/${maxAttempts})`
       );
-      await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 2e3));
     }
     this.logger.warn(`Firehose ${logicalId} did not reach ACTIVE after ${maxAttempts} attempts`);
   }
@@ -64864,7 +64864,7 @@ var ASGProvider = class {
     );
   }
   sleep(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   // ─── Sub-shape diff helpers ───────────────────────────────────────
   // Each helper is a no-op when before/after JSON is identical (the cheap
@@ -66804,7 +66804,7 @@ Acquiring lock for stack ${stackName}...`);
                   logger.debug(
                     `  \u23F3 Retrying delete ${logicalId} in ${delay2 / 1e3}s (attempt ${attempt + 1}/${maxAttempts})`
                   );
-                  await new Promise((resolve6) => setTimeout(resolve6, delay2));
+                  await new Promise((resolve8) => setTimeout(resolve8, delay2));
                 }
               }
               if (lastDeleteError)
@@ -70036,7 +70036,7 @@ async function captureObservedForImportedResources(stackState, providerRegistry,
 // src/cli/commands/local-invoke.ts
 import { cpSync as cpSync2, mkdtempSync as mkdtempSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 import * as path2 from "node:path";
 import { Command as Command15, Option as Option8 } from "commander";
 
@@ -70855,7 +70855,7 @@ async function ecrLogin(client, accountId, region) {
   const token = Buffer.from(authData.authorizationToken, "base64").toString();
   const [username, password] = token.split(":");
   const endpoint = authData.proxyEndpoint || `https://${accountId}.dkr.ecr.${region}.amazonaws.com`;
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve8, reject) => {
     const proc = spawn4("docker", ["login", "--username", username, "--password-stdin", endpoint], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -70865,7 +70865,7 @@ async function ecrLogin(client, accountId, region) {
     });
     proc.on("close", (code) => {
       if (code === 0)
-        resolve6();
+        resolve8();
       else
         reject(new LocalInvokeBuildError(`ECR login failed: ${stderr.trim()}`));
     });
@@ -70894,12 +70894,12 @@ async function isImageInLocalCache(imageRef) {
   }
 }
 function runForeground2(cmd, args) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const proc = spawn4(cmd, args, { stdio: "inherit" });
     proc.on("error", (err) => reject(new LocalInvokeBuildError(`${cmd} failed: ${err.message}`)));
     proc.on("close", (code) => {
       if (code === 0)
-        resolve6();
+        resolve8();
       else
         reject(new LocalInvokeBuildError(`${cmd} exited with code ${code}`));
     });
@@ -71246,6 +71246,7 @@ function discoverRestV1Method(logicalId, resource, template, stackName) {
       source: "rest-v1",
       apiVersion: "v1",
       stage,
+      apiLogicalId: restApiLogicalId,
       declaredAt: `${stackName}/${logicalId}`
     }
   ];
@@ -71342,8 +71343,8 @@ function discoverHttpApiRoute(logicalId, resource, template, stackName) {
       );
     }
   }
-  const routeKey = props["RouteKey"];
-  if (typeof routeKey !== "string" || routeKey.length === 0) {
+  const routeKey2 = props["RouteKey"];
+  if (typeof routeKey2 !== "string" || routeKey2.length === 0) {
     throw new Error(
       `${stackName}/${logicalId} (AWS::ApiGatewayV2::Route): RouteKey must be a string`
     );
@@ -71379,7 +71380,7 @@ function discoverHttpApiRoute(logicalId, resource, template, stackName) {
     integrationProps["IntegrationUri"],
     `${stackName}/${integrationLogicalId}.IntegrationUri`
   );
-  const { method, pathPattern } = parseRouteKey(routeKey);
+  const { method, pathPattern } = parseRouteKey(routeKey2);
   return [
     {
       method,
@@ -71388,6 +71389,7 @@ function discoverHttpApiRoute(logicalId, resource, template, stackName) {
       source: "http-api",
       apiVersion: "v2",
       stage: "$default",
+      apiLogicalId,
       declaredAt: `${stackName}/${logicalId}`
     }
   ];
@@ -71438,9 +71440,9 @@ function resolveLambdaArnIntrinsic(value, location) {
       }
     }
     if ("Fn::Join" in obj) {
-      const join9 = obj["Fn::Join"];
-      if (Array.isArray(join9) && join9.length === 2 && Array.isArray(join9[1])) {
-        const parts = join9[1];
+      const join11 = obj["Fn::Join"];
+      if (Array.isArray(join11) && join11.length === 2 && Array.isArray(join11[1])) {
+        const parts = join11[1];
         const literalParts = parts.filter((p) => typeof p === "string").join("");
         if (literalParts.includes(":lambda:path/2015-03-31/functions/")) {
           for (const p of parts) {
@@ -71471,10 +71473,10 @@ function parseHttpApiTargetIntegration(target, location) {
   }
   if (target && typeof target === "object" && !Array.isArray(target)) {
     const obj = target;
-    const join9 = obj["Fn::Join"];
-    if (Array.isArray(join9) && join9.length === 2 && Array.isArray(join9[1])) {
-      const sep = join9[0];
-      const parts = join9[1];
+    const join11 = obj["Fn::Join"];
+    if (Array.isArray(join11) && join11.length === 2 && Array.isArray(join11[1])) {
+      const sep = join11[0];
+      const parts = join11[1];
       if (sep === "/" && parts.length === 2 && parts[0] === "integrations") {
         const ref = pickRefLogicalId(parts[1]);
         if (ref)
@@ -71493,14 +71495,14 @@ function parseHttpApiTargetIntegration(target, location) {
     )}).`
   );
 }
-function parseRouteKey(routeKey) {
-  if (routeKey === "$default") {
+function parseRouteKey(routeKey2) {
+  if (routeKey2 === "$default") {
     return { method: "ANY", pathPattern: "$default" };
   }
-  const m = /^([A-Za-z]+)\s+(\S+)$/.exec(routeKey);
+  const m = /^([A-Za-z]+)\s+(\S+)$/.exec(routeKey2);
   if (!m) {
     throw new Error(
-      `RouteKey '${routeKey}' is malformed: expected '<METHOD> <path>' (e.g. 'GET /items/{id}') or '$default'.`
+      `RouteKey '${routeKey2}' is malformed: expected '<METHOD> <path>' (e.g. 'GET /items/{id}') or '$default'.`
     );
   }
   return { method: m[1].toUpperCase(), pathPattern: m[2] };
@@ -71532,6 +71534,7 @@ function createContainerPool(specs, options) {
   const idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
   const streamingEnabled = options.streamLogs !== false;
   const entries = /* @__PURE__ */ new Map();
+  let disposed = false;
   const inFlightStarts = /* @__PURE__ */ new Set();
   for (const logicalId of specs.keys()) {
     entries.set(logicalId, emptyEntry(logicalId));
@@ -71543,7 +71546,8 @@ function createContainerPool(specs, options) {
       inUse: /* @__PURE__ */ new Set(),
       waitQueue: [],
       idleTimer: null,
-      growthMutex: Promise.resolve()
+      growthMutex: Promise.resolve(),
+      drainResolvers: []
     };
   }
   async function startOne(spec) {
@@ -71680,6 +71684,18 @@ function createContainerPool(specs, options) {
       if (!entry)
         return;
       entry.inUse.delete(handle);
+      if (disposed) {
+        entry.warm.push(handle);
+        if (entry.inUse.size === 0) {
+          for (const resolve8 of entry.drainResolvers.splice(0, entry.drainResolvers.length)) {
+            try {
+              resolve8();
+            } catch {
+            }
+          }
+        }
+        return;
+      }
       const waiter = entry.waitQueue.shift();
       if (waiter) {
         entry.inUse.add(handle);
@@ -71688,10 +71704,22 @@ function createContainerPool(specs, options) {
       }
       entry.warm.push(handle);
       resetIdleTimer(entry);
+      if (entry.inUse.size === 0 && entry.drainResolvers.length > 0) {
+        for (const resolve8 of entry.drainResolvers.splice(0, entry.drainResolvers.length)) {
+          try {
+            resolve8();
+          } catch {
+          }
+        }
+      }
     },
     async dispose() {
+      if (disposed) {
+        logger.debug("Container pool dispose() called more than once; ignoring");
+        return;
+      }
+      disposed = true;
       logger.debug("Disposing container pool");
-      const allHandles = [];
       for (const entry of entries.values()) {
         if (entry.idleTimer) {
           clearTimeout(entry.idleTimer);
@@ -71705,6 +71733,43 @@ function createContainerPool(specs, options) {
           } catch {
           }
         }
+      }
+      const drainTimeoutMs = 3e4;
+      const drainStart = Date.now();
+      const entryDrains = [];
+      for (const entry of entries.values()) {
+        if (entry.inUse.size === 0)
+          continue;
+        entryDrains.push(
+          new Promise((resolveDrain) => {
+            entry.drainResolvers.push(() => resolveDrain({ entry, timedOut: false }));
+            const t = setTimeout(() => {
+              resolveDrain({ entry, timedOut: true });
+            }, drainTimeoutMs);
+            t.unref?.();
+          })
+        );
+      }
+      if (entryDrains.length > 0) {
+        logger.debug(
+          `Waiting for ${entryDrains.length} entry/entries' in-flight handle(s) to drain before teardown`
+        );
+        const drainResults = await Promise.all(entryDrains);
+        let anyTimedOut = false;
+        for (const r of drainResults) {
+          if (r.timedOut) {
+            anyTimedOut = true;
+            logger.warn(
+              `Container pool dispose timed out waiting for ${r.entry.inUse.size} in-flight handle(s) on ${r.entry.logicalId} after ${drainTimeoutMs}ms; tearing down anyway. The verify.sh \`docker rm -f cdkd-local-*\` sweep is the safety net.`
+            );
+          }
+        }
+        if (!anyTimedOut) {
+          logger.debug(`In-flight drain completed in ${Date.now() - drainStart}ms`);
+        }
+      }
+      const allHandles = [];
+      for (const entry of entries.values()) {
         allHandles.push(...entry.warm.splice(0, entry.warm.length));
         for (const h of entry.inUse)
           allHandles.push(h);
@@ -71715,12 +71780,12 @@ function createContainerPool(specs, options) {
         logger.debug(
           `Waiting for ${startPromises.length} in-flight container start(s) to settle before teardown`
         );
-        const drainTimeoutMs = 5e3;
+        const drainTimeoutMs2 = 5e3;
         const wrapped = startPromises.map(
           (p) => Promise.race([
             p.then((h) => ({ kind: "ok", handle: h })),
             new Promise((r) => {
-              const t = setTimeout(() => r({ kind: "timeout" }), drainTimeoutMs);
+              const t = setTimeout(() => r({ kind: "timeout" }), drainTimeoutMs2);
               t.unref?.();
             })
           ]).catch((err) => {
@@ -71741,7 +71806,7 @@ function createContainerPool(specs, options) {
         }
         if (timedOut > 0) {
           logger.warn(
-            `Container pool disposed with ${timedOut} in-flight start(s) still pending after ${drainTimeoutMs}ms; relying on docker --rm + the verify.sh sweep to clean up.`
+            `Container pool disposed with ${timedOut} in-flight start(s) still pending after ${drainTimeoutMs2}ms; relying on docker --rm + the verify.sh sweep to clean up.`
           );
         }
         inFlightStarts.clear();
@@ -71777,17 +71842,20 @@ function buildHttpApiV2Event(req, ctx, opts = {}) {
   const contentType = headers["content-type"] ?? "";
   const { body, isBase64Encoded } = encodeBody(req.body, contentType);
   const now = opts.now ? opts.now() : /* @__PURE__ */ new Date();
-  const routeKey = ctx.route.pathPattern === "$default" ? "$default" : `${ctx.route.method} ${ctx.route.pathPattern}`;
+  const routeKey2 = ctx.route.pathPattern === "$default" ? "$default" : `${ctx.route.method} ${ctx.route.pathPattern}`;
   const event = {
     version: "2.0",
-    routeKey,
+    routeKey: routeKey2,
     rawPath,
     rawQueryString,
     cookies,
     headers,
     queryStringParameters,
     pathParameters: decodePathParameters(ctx.pathParameters),
-    stageVariables: null,
+    // PR 8c: surface the route's resolved Stage Variables (or `null`
+    // for routes without a Stage — Function URLs, plus HTTP API routes
+    // when no Stage with matching variables was attached).
+    stageVariables: ctx.route.stageVariables ?? null,
     requestContext: {
       accountId: MOCK_ACCOUNT_ID,
       apiId: MOCK_API_ID,
@@ -71801,7 +71869,7 @@ function buildHttpApiV2Event(req, ctx, opts = {}) {
         userAgent
       },
       requestId: randomUUID(),
-      routeKey,
+      routeKey: routeKey2,
       stage: ctx.route.stage,
       time: formatRequestTime(now),
       timeEpoch: now.getTime(),
@@ -71830,7 +71898,10 @@ function buildRestV1Event(req, ctx, opts = {}) {
     queryStringParameters: Object.keys(queryStringParameters).length > 0 ? queryStringParameters : null,
     multiValueQueryStringParameters: Object.keys(multiValueQueryStringParameters).length > 0 ? multiValueQueryStringParameters : null,
     pathParameters: Object.keys(pathParams).length > 0 ? pathParams : null,
-    stageVariables: null,
+    // PR 8c: surface the route's resolved Stage Variables (or `null`).
+    // REST v1 hardcoded `null` pre-PR; with `attachStageContext` the
+    // route now carries the deployed Stage's `Variables` map.
+    stageVariables: ctx.route.stageVariables ?? null,
     requestContext: {
       accountId: MOCK_ACCOUNT_ID,
       apiId: MOCK_API_ID,
@@ -72263,6 +72334,143 @@ function isPlaceholder(segment) {
   return /^\{[^/{}+]+\}$/.test(segment);
 }
 
+// src/local/cors-handler.ts
+function buildCorsConfigByApiId(template) {
+  const out = /* @__PURE__ */ new Map();
+  const resources = template.Resources ?? {};
+  for (const [logicalId, resource] of Object.entries(resources)) {
+    if (resource.Type !== "AWS::ApiGatewayV2::Api")
+      continue;
+    const props = resource.Properties ?? {};
+    const raw = props["CorsConfiguration"];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      continue;
+    const parsed = parseCorsConfiguration(raw);
+    if (parsed)
+      out.set(logicalId, parsed);
+  }
+  return out;
+}
+function parseCorsConfiguration(raw) {
+  const allowOrigins = pickStringArray(raw["AllowOrigins"]);
+  const allowMethods = pickStringArray(raw["AllowMethods"]);
+  const allowHeaders = pickStringArray(raw["AllowHeaders"]);
+  const exposeHeaders = pickStringArray(raw["ExposeHeaders"]);
+  const maxAgeRaw = raw["MaxAge"];
+  const allowCreds = raw["AllowCredentials"];
+  if (allowOrigins.length === 0 && allowMethods.length === 0 && allowHeaders.length === 0 && exposeHeaders.length === 0 && maxAgeRaw === void 0 && allowCreds === void 0) {
+    return void 0;
+  }
+  const config = {
+    AllowOrigins: allowOrigins,
+    AllowMethods: allowMethods,
+    AllowHeaders: allowHeaders,
+    ExposeHeaders: exposeHeaders
+  };
+  if (typeof maxAgeRaw === "number" && Number.isFinite(maxAgeRaw)) {
+    config.MaxAge = Math.trunc(maxAgeRaw);
+  }
+  if (typeof allowCreds === "boolean") {
+    config.AllowCredentials = allowCreds;
+  }
+  return config;
+}
+function pickStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  const out = [];
+  for (const v of value)
+    if (typeof v === "string")
+      out.push(v);
+  return out;
+}
+function matchPreflight(req, config) {
+  if (req.method.toUpperCase() !== "OPTIONS")
+    return null;
+  const headersLower = {};
+  for (const [name, values] of Object.entries(req.headers)) {
+    if (values.length === 0)
+      continue;
+    headersLower[name.toLowerCase()] = values.join(",");
+  }
+  const origin = headersLower["origin"];
+  const requestedMethod = headersLower["access-control-request-method"];
+  if (!origin || !requestedMethod) {
+    return null;
+  }
+  const originMatch = matchOrigin(origin, config.AllowOrigins);
+  if (!originMatch)
+    return null;
+  const methodMatch = matchToken(requestedMethod, config.AllowMethods);
+  if (!methodMatch)
+    return null;
+  const requestedHeaders = headersLower["access-control-request-headers"] ?? "";
+  if (!matchHeaderList(requestedHeaders, config.AllowHeaders))
+    return null;
+  const responseHeaders = {
+    "access-control-allow-origin": originMatch === "*" ? "*" : origin,
+    "access-control-allow-methods": methodMatch === "*" ? requestedMethod : methodMatch
+  };
+  if (requestedHeaders.length > 0) {
+    responseHeaders["access-control-allow-headers"] = requestedHeaders;
+  } else if (config.AllowHeaders.length > 0 && !config.AllowHeaders.includes("*")) {
+    responseHeaders["access-control-allow-headers"] = config.AllowHeaders.join(",");
+  }
+  if (config.ExposeHeaders.length > 0) {
+    responseHeaders["access-control-expose-headers"] = config.ExposeHeaders.join(",");
+  }
+  if (config.MaxAge !== void 0) {
+    responseHeaders["access-control-max-age"] = String(config.MaxAge);
+  }
+  if (config.AllowCredentials === true) {
+    responseHeaders["access-control-allow-origin"] = origin;
+    responseHeaders["access-control-allow-credentials"] = "true";
+  }
+  responseHeaders["vary"] = "Origin";
+  return { statusCode: 204, headers: responseHeaders };
+}
+function matchOrigin(requestOrigin, allowOrigins) {
+  if (allowOrigins.length === 0)
+    return null;
+  if (allowOrigins.includes("*"))
+    return "*";
+  for (const allowed of allowOrigins) {
+    if (allowed === requestOrigin)
+      return allowed;
+  }
+  return null;
+}
+function matchToken(token, allowed) {
+  if (allowed.length === 0)
+    return null;
+  if (allowed.includes("*"))
+    return "*";
+  const lower = token.toLowerCase();
+  for (const a of allowed) {
+    if (a.toLowerCase() === lower)
+      return a;
+  }
+  return null;
+}
+function matchHeaderList(headerList, allowed) {
+  const trimmed = headerList.trim();
+  if (trimmed.length === 0)
+    return true;
+  if (allowed.includes("*"))
+    return true;
+  if (allowed.length === 0)
+    return false;
+  const allowedLower = new Set(allowed.map((s) => s.toLowerCase()));
+  for (const entry of trimmed.split(",")) {
+    const e = entry.trim().toLowerCase();
+    if (e.length === 0)
+      return false;
+    if (!allowedLower.has(e))
+      return false;
+  }
+  return true;
+}
+
 // src/local/authorizer-resolver.ts
 function resolveRestV1Authorizer(authorizerLogicalId, template, stackName, declaredAt) {
   const authResource = template.Resources?.[authorizerLogicalId];
@@ -72399,9 +72607,9 @@ function resolveLambdaArn(value, location) {
       }
     }
     if ("Fn::Join" in obj) {
-      const join9 = obj["Fn::Join"];
-      if (Array.isArray(join9) && join9.length === 2 && Array.isArray(join9[1])) {
-        const parts = join9[1];
+      const join11 = obj["Fn::Join"];
+      if (Array.isArray(join11) && join11.length === 2 && Array.isArray(join11[1])) {
+        const parts = join11[1];
         const literal = parts.filter((p) => typeof p === "string").join("");
         if (literal.includes(":lambda:path/2015-03-31/functions/")) {
           for (const p of parts) {
@@ -73075,8 +73283,9 @@ function base64UrlDecodeToBuffer(input) {
 // src/local/http-server.ts
 async function startApiServer(opts) {
   const logger = getLogger().child("start-api");
+  let currentState = opts.state;
   const server = createServer2((req, res) => {
-    handleRequest(req, res, opts).catch((err) => {
+    handleRequest(req, res, currentState, opts).catch((err) => {
       logger.error(
         `Unhandled request error: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
       );
@@ -73114,22 +73323,31 @@ async function startApiServer(opts) {
         server.close(() => resolveClose());
         server.closeAllConnections?.();
       });
-    }
+    },
+    setServerState: (next) => {
+      const prev = currentState;
+      currentState = next;
+      return prev;
+    },
+    getServerState: () => currentState
   };
 }
-async function handleRequest(req, res, opts) {
+async function handleRequest(req, res, state, opts) {
   const logger = getLogger().child("start-api");
   const bodyBuf = await readBody(req);
   const rawUrl = req.url ?? "/";
   const method = (req.method ?? "GET").toUpperCase();
   const requestPath = rawUrl.split("?")[0] ?? "/";
-  const flatRoutes = opts.routes.map((r) => r.route);
+  const preflightHandled = method === "OPTIONS" ? maybeHandleCorsPreflight(req, res, requestPath, state) : false;
+  if (preflightHandled)
+    return;
+  const flatRoutes = state.routes.map((r) => r.route);
   const match = matchRoute(method, requestPath, flatRoutes);
   if (!match) {
     writeError(res, 404, '{"message":"Not Found"}');
     return;
   }
-  const matchedEntry = opts.routes.find(
+  const matchedEntry = state.routes.find(
     (r) => r.route.declaredAt === match.route.declaredAt && r.route.method === match.route.method
   );
   const authorizer = matchedEntry?.authorizer;
@@ -73154,6 +73372,7 @@ async function handleRequest(req, res, opts) {
         authorizer,
         snapshot,
         matchCtx,
+        state,
         opts,
         baseEvent["requestContext"]
       );
@@ -73176,7 +73395,7 @@ async function handleRequest(req, res, opts) {
   }
   let handle;
   try {
-    handle = await opts.pool.acquire(match.route.lambdaLogicalId);
+    handle = await state.pool.acquire(match.route.lambdaLogicalId);
   } catch (err) {
     logger.error(
       `Failed to acquire container for ${match.route.lambdaLogicalId}: ${err instanceof Error ? err.message : String(err)}`
@@ -73210,10 +73429,85 @@ async function handleRequest(req, res, opts) {
       res.end();
     }
   } finally {
-    opts.pool.release(handle);
+    state.pool.release(handle);
+  }
+}
+function maybeHandleCorsPreflight(req, res, requestPath, state) {
+  if (state.corsConfigByApiId.size === 0)
+    return false;
+  const headers = collectHeaders(req);
+  const requestedMethodHeader = pickFirstHeaderValue(headers, "access-control-request-method");
+  if (!requestedMethodHeader)
+    return false;
+  const flatRoutes = state.routes.map((r) => r.route);
+  const surrogateMatch = matchRoute(requestedMethodHeader, requestPath, flatRoutes);
+  if (!surrogateMatch)
+    return false;
+  const route = surrogateMatch.route;
+  if (route.apiVersion !== "v2" || !route.apiLogicalId)
+    return false;
+  const surrogateApiId = route.apiLogicalId;
+  const explicitOptionsRoute = flatRoutes.find(
+    (r) => r.apiLogicalId === surrogateApiId && r.method.toUpperCase() === "OPTIONS" && pathPatternMatchesPath(r.pathPattern, requestPath)
+  );
+  if (explicitOptionsRoute)
+    return false;
+  const cors = state.corsConfigByApiId.get(surrogateApiId);
+  if (!cors)
+    return false;
+  const preflight = matchPreflight({ method: "OPTIONS", headers }, cors);
+  if (!preflight)
+    return false;
+  res.statusCode = preflight.statusCode;
+  for (const [name, value] of Object.entries(preflight.headers)) {
+    res.setHeader(name, value);
+  }
+  res.end();
+  return true;
+}
+function pathPatternMatchesPath(pattern, requestPath) {
+  if (pattern === "$default")
+    return true;
+  const requestSegments = requestPath.split("/").filter((s) => s.length > 0);
+  const patternSegments = pattern.split("/").filter((s) => s.length > 0);
+  if (patternSegments.length > 0) {
+    const tail = patternSegments[patternSegments.length - 1];
+    if (/^\{[^/{}]+\+\}$/.test(tail)) {
+      const fixed = patternSegments.length - 1;
+      if (requestSegments.length < fixed)
+        return false;
+      for (let i = 0; i < fixed; i++) {
+        const ps = patternSegments[i];
+        const rs = requestSegments[i];
+        if (/^\{[^/{}+]+\}$/.test(ps))
+          continue;
+        if (ps !== rs)
+          return false;
+      }
+      return true;
+    }
+  }
+  if (patternSegments.length !== requestSegments.length)
+    return false;
+  for (let i = 0; i < patternSegments.length; i++) {
+    const ps = patternSegments[i];
+    const rs = requestSegments[i];
+    if (/^\{[^/{}+]+\}$/.test(ps))
+      continue;
+    if (ps !== rs)
+      return false;
   }
+  return true;
+}
+function pickFirstHeaderValue(headers, name) {
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === lower && v.length > 0)
+      return v[0];
+  }
+  return null;
 }
-async function runAuthorizerPass(authorizer, snapshot, matchCtx, opts, requestContextV2) {
+async function runAuthorizerPass(authorizer, snapshot, matchCtx, state, opts, requestContextV2) {
   const headers = lowercaseSingularHeaders(snapshot.headers);
   const queryStringParameters = parseQueryStringSingular(snapshot.rawUrl);
   const sourceIp = pickSourceIp(matchCtx.route.apiVersion, requestContextV2, snapshot);
@@ -73249,7 +73543,7 @@ async function runAuthorizerPass(authorizer, snapshot, matchCtx, opts, requestCo
       }
     }
     const result2 = await invokeTokenAuthorizer(authorizer, reqSnap, {
-      pool: opts.pool,
+      pool: state.pool,
       rieTimeoutMs: opts.rieTimeoutMs,
       methodArn,
       mockAccountId: "123456789012",
@@ -73280,7 +73574,7 @@ async function runAuthorizerPass(authorizer, snapshot, matchCtx, opts, requestCo
       }
     }
     const result2 = await invokeRequestAuthorizer(authorizer, reqSnap, {
-      pool: opts.pool,
+      pool: state.pool,
       rieTimeoutMs: opts.rieTimeoutMs,
       methodArn,
       mockAccountId: "123456789012",
@@ -73462,6 +73756,1985 @@ function writeError(res, statusCode, body = '{"message":"Internal server error"}
   res.end(body);
 }
 
+// src/local/stage-resolver.ts
+function buildStageMap(template, stageOverride) {
+  const out = /* @__PURE__ */ new Map();
+  const resources = template.Resources ?? {};
+  const restStagesByApi = /* @__PURE__ */ new Map();
+  const v2StagesByApi = /* @__PURE__ */ new Map();
+  for (const [logicalId, resource] of Object.entries(resources)) {
+    if (resource.Type === "AWS::ApiGateway::Stage") {
+      const apiId = pickRefLogicalId3((resource.Properties ?? {})["RestApiId"]);
+      if (apiId)
+        appendByApi(restStagesByApi, apiId, logicalId, resource);
+    } else if (resource.Type === "AWS::ApiGatewayV2::Stage") {
+      const apiId = pickRefLogicalId3((resource.Properties ?? {})["ApiId"]);
+      if (apiId)
+        appendByApi(v2StagesByApi, apiId, logicalId, resource);
+    }
+  }
+  for (const [apiId, stages] of restStagesByApi) {
+    const picked = pickStage(stages, stageOverride);
+    if (picked)
+      out.set(apiId, toResolvedStage(picked, "v1"));
+  }
+  for (const [apiId, stages] of v2StagesByApi) {
+    const picked = pickStage(stages, stageOverride);
+    if (picked)
+      out.set(apiId, toResolvedStage(picked, "v2"));
+  }
+  return out;
+}
+function appendByApi(bucket, apiId, stageId, resource) {
+  const list = bucket.get(apiId) ?? [];
+  list.push({ id: stageId, resource });
+  bucket.set(apiId, list);
+}
+function pickStage(stages, stageOverride) {
+  if (stages.length === 0)
+    return void 0;
+  if (stageOverride) {
+    for (const s of stages) {
+      const props = s.resource.Properties ?? {};
+      if (props["StageName"] === stageOverride)
+        return s;
+    }
+    return void 0;
+  }
+  return stages[0];
+}
+function toResolvedStage(stage, apiVersion) {
+  const props = stage.resource.Properties ?? {};
+  const stageName = typeof props["StageName"] === "string" ? props["StageName"] : "$default";
+  const rawVars = apiVersion === "v1" ? props["Variables"] : props["StageVariables"];
+  let variables = null;
+  if (rawVars && typeof rawVars === "object" && !Array.isArray(rawVars)) {
+    const map = {};
+    for (const [k, v] of Object.entries(rawVars)) {
+      if (typeof v === "string") {
+        map[k] = v;
+      }
+    }
+    variables = Object.keys(map).length > 0 ? map : null;
+  }
+  return { stageLogicalId: stage.id, stageName, apiVersion, variables };
+}
+function attachStageContext(routes, stageMap) {
+  for (const route of routes) {
+    if (!route.apiLogicalId) {
+      route.stageVariables = null;
+      continue;
+    }
+    const stage = stageMap.get(route.apiLogicalId);
+    if (!stage) {
+      route.stageVariables = null;
+      continue;
+    }
+    route.stageVariables = stage.variables;
+    if (route.source === "rest-v1") {
+      route.stage = stage.stageName;
+    }
+  }
+}
+function pickRefLogicalId3(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const ref = value["Ref"];
+    if (typeof ref === "string")
+      return ref;
+  }
+  return null;
+}
+
+// node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
+import { EventEmitter } from "node:events";
+import { stat as statcb, Stats } from "node:fs";
+import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import * as sp2 from "node:path";
+
+// node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
+import { Readable } from "node:stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path3) => statMethod(path3, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path3, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path3));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path3, depth) {
+    let files;
+    try {
+      files = await readdir(path3, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path3 };
+  }
+  async _formatEntry(dirent, path3) {
+    let entry;
+    const basename4 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path3, basename4));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "node:fs/promises";
+import { type as osType } from "node:os";
+import * as sp from "node:path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path3, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path3);
+    emitRaw(rawEvent, evPath, { watchedPath: path3 });
+    if (evPath && path3 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path3, evPath), KEY_LISTENERS, sp.join(path3, evPath));
+    }
+  };
+  try {
+    return fs_watch(path3, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path3, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path3, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path3,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path3, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path3, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path3, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path3, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path3);
+    const basename4 = sp.basename(path3);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename4);
+    const absolutePath = sp.resolve(path3);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path3, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path3, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname7 = sp.dirname(file);
+    const basename4 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname7);
+    let prevStats = stats;
+    if (parent.has(basename4))
+      return;
+    const listener = async (path3, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path3);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path3, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname7, basename4);
+        }
+      } else if (parent.has(basename4)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path3, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path3);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path3, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path3, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path3 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path3, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path3 = sp.join(dir, sp.relative(dir, path3));
+        this._addToNodeFs(path3, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve8, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve8(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path3, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path3) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path3);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path3);
+        const targetPath = follow ? await fsrealpath(path3) : path3;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path3) : path3;
+        if (this.fsw.closed)
+          return;
+        const parent = sp.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path3, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sp.resolve(path3), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path3, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path3;
+      }
+    }
+  }
+};
+
+// node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sp2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path3) {
+  if (typeof path3 !== "string")
+    throw new Error("string expected");
+  path3 = sp2.normalize(path3);
+  path3 = path3.replace(/\\/g, "/");
+  let prepend = false;
+  if (path3.startsWith("//"))
+    prepend = true;
+  path3 = path3.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path3 = "/" + path3;
+  return path3;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path3 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path3, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path3) => toUnix(sp2.normalize(toUnix(path3)));
+var normalizeIgnored = (cwd = "") => (path3) => {
+  if (typeof path3 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path3) ? path3 : sp2.join(cwd, path3));
+  } else {
+    return path3;
+  }
+};
+var getAbsolutePath = (path3, cwd) => {
+  if (sp2.isAbsolute(path3)) {
+    return path3;
+  }
+  return sp2.join(cwd, path3);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path3, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path3;
+    this.path = path3 = path3.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path3) => {
+        const absPath = getAbsolutePath(path3, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path3) => {
+      this._removeIgnoredPath(path3);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path3) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path3, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path3) => {
+      if (!sp2.isAbsolute(path3) && !this._closers.has(path3)) {
+        if (cwd)
+          path3 = sp2.join(cwd, path3);
+        path3 = sp2.resolve(path3);
+      }
+      this._closePath(path3);
+      this._addIgnoredPath(path3);
+      if (this._watched.has(path3)) {
+        this._addIgnoredPath({
+          path: path3,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path3, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path3 = sp2.normalize(path3);
+    if (opts.cwd)
+      path3 = sp2.relative(opts.cwd, path3);
+    const args = [path3];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path3))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path3, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path4) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path4);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path3)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path3);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path3, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path3, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path3) : path3;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path3, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path3);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path3);
+      const count = item ? item.count : 0;
+      action.delete(path3);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path3, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path3, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path3;
+    if (this.options.cwd && !sp2.isAbsolute(path3)) {
+      fullPath = sp2.join(this.options.cwd, path3);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path3)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path3).lastChange = now2;
+        }
+        const pw = writes.get(path3);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path3);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path3)) {
+      writes.set(path3, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path3);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path3, stats) {
+    if (this.options.atomic && DOT_RE.test(path3))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path3, stats);
+  }
+  _isntIgnored(path3, stat4) {
+    return !this._isIgnored(path3, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path3) {
+    return new WatchHelper(path3, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sp2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path3 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path3);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path3) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path3, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path3);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path3, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path3;
+    if (this.options.cwd)
+      relPath = sp2.relative(this.options.cwd, path3);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path3);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path3))
+      this._emit(eventName, path3);
+    this._closePath(path3);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path3) {
+    this._closeFile(path3);
+    const dir = sp2.dirname(path3);
+    this._getWatchedDir(dir).remove(sp2.basename(path3));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path3) {
+    const closers = this._closers.get(path3);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path3);
+  }
+  _addPathCloser(path3, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path3);
+    if (!list) {
+      list = [];
+      this._closers.set(path3, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+
+// src/local/file-watcher.ts
+var DEFAULT_DEBOUNCE_MS = 500;
+function createFileWatcher(options) {
+  const logger = getLogger().child("start-api-watch");
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const ignoreInitial = options.ignoreInitial !== false;
+  const watcher = watch([...options.paths], {
+    ignoreInitial,
+    // Don't follow symlinks — asset directories under `cdk.out/asset.<hash>/`
+    // are real directories; following symlinks would risk cycling into
+    // `node_modules` or similar.
+    followSymlinks: false,
+    // Don't crash on permission errors.
+    ignorePermissionErrors: true
+  });
+  let timer = null;
+  let closed = false;
+  const fire = () => {
+    if (closed)
+      return;
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      if (closed)
+        return;
+      try {
+        options.onChange();
+      } catch (err) {
+        logger.warn(`onChange callback threw: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }, debounceMs);
+    timer.unref?.();
+  };
+  watcher.on("add", fire);
+  watcher.on("change", fire);
+  watcher.on("unlink", fire);
+  watcher.on("error", (err) => {
+    logger.debug(
+      `chokidar error: ${err instanceof Error ? err.message : String(err)}. Continuing.`
+    );
+  });
+  let currentPaths = new Set(options.paths);
+  return {
+    update: (paths) => {
+      if (closed)
+        return;
+      const next = new Set(paths);
+      const toAdd = [];
+      const toRemove = [];
+      for (const p of next)
+        if (!currentPaths.has(p))
+          toAdd.push(p);
+      for (const p of currentPaths)
+        if (!next.has(p))
+          toRemove.push(p);
+      if (toAdd.length > 0)
+        watcher.add(toAdd);
+      if (toRemove.length > 0)
+        watcher.unwatch(toRemove);
+      currentPaths = next;
+    },
+    close: async () => {
+      closed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      await watcher.close();
+    }
+  };
+}
+
+// src/local/reload-orchestrator.ts
+function createReloadOrchestrator(deps) {
+  const logger = getLogger().child("start-api-reload");
+  let chain = Promise.resolve();
+  return {
+    reload() {
+      const next = chain.then(() => runOneReload(deps, logger));
+      chain = next.catch(() => void 0);
+      return next;
+    }
+  };
+}
+async function runOneReload(deps, logger) {
+  const previousState = deps.getServerState();
+  const start = Date.now();
+  let material;
+  try {
+    material = await deps.synthesizeAndBuild();
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger.warn(`cdk synth failed during reload; keeping previous version. (${reason})`);
+    return { ok: false, reason, added: [], removed: [], rebuiltLambdas: [] };
+  }
+  const oldRoutes = previousState.routes;
+  const newRoutes = material.routes;
+  const oldKeys = new Set(oldRoutes.map((r) => routeKey(r.route)));
+  const newKeys = new Set(newRoutes.map((r) => routeKey(r.route)));
+  const added = newRoutes.filter((r) => !oldKeys.has(routeKey(r.route)));
+  const removed = oldRoutes.filter((r) => !newKeys.has(routeKey(r.route)));
+  const previousSpecs = pickSpecsFromState(previousState);
+  const rebuiltLambdas = [];
+  for (const [logicalId, newSpec] of material.specs) {
+    const oldSpec = previousSpecs.get(logicalId);
+    if (!oldSpec)
+      continue;
+    if (specSignature(oldSpec) !== specSignature(newSpec)) {
+      rebuiltLambdas.push(logicalId);
+    }
+  }
+  const newPool = deps.buildPool(material.specs);
+  Object.defineProperty(newPool, "__cdkdSpecs", {
+    value: material.specs,
+    enumerable: false,
+    configurable: true
+  });
+  const newState = {
+    routes: material.routes,
+    pool: newPool,
+    corsConfigByApiId: material.corsConfigByApiId
+  };
+  deps.setServerState(newState);
+  void previousState.pool.dispose().catch(
+    (err) => logger.debug(
+      `Previous pool dispose() failed: ${err instanceof Error ? err.message : String(err)}`
+    )
+  );
+  const elapsed = Date.now() - start;
+  logger.info(
+    `Reloaded in ${elapsed}ms: +${added.length} route(s), -${removed.length} route(s), ${rebuiltLambdas.length} Lambda(s) rebuilt.`
+  );
+  return {
+    ok: true,
+    added,
+    removed,
+    rebuiltLambdas,
+    newState
+  };
+}
+function routeKey(route) {
+  return [route.method, route.pathPattern, route.lambdaLogicalId, route.source, route.apiVersion].map((s) => String(s)).join("|");
+}
+function specSignature(spec) {
+  return JSON.stringify({
+    codeDir: spec.codeDir,
+    env: spec.env,
+    handler: spec.lambda.handler,
+    runtime: spec.lambda.runtime,
+    containerHost: spec.containerHost,
+    debugPort: spec.debugPort ?? null
+  });
+}
+function pickSpecsFromState(state) {
+  const tagged = state.pool.__cdkdSpecs;
+  return tagged ?? /* @__PURE__ */ new Map();
+}
+
 // src/local/authorizer-cache.ts
 function createAuthorizerCache(opts = {}) {
   const now = opts.now ?? (() => Date.now());
@@ -73515,67 +75788,123 @@ async function localStartApiCommand(options) {
   if (!appCmd) {
     throw new Error('No CDK app specified. Pass --app, set CDKD_APP, or add "app" to cdk.json.');
   }
-  logger.info("Synthesizing CDK app...");
-  const synthesizer = new Synthesizer();
-  const context = parseContextOptions(options.context);
-  const synthOpts = {
-    app: appCmd,
-    output: options.output,
-    ...options.region && { region: options.region },
-    ...options.profile && { profile: options.profile },
-    ...Object.keys(context).length > 0 && { context }
-  };
-  const { stacks } = await synthesizer.synthesize(synthOpts);
-  const targetStacks = pickTargetStacks(stacks, options.stack);
-  if (targetStacks.length === 0) {
-    throw new Error("No stacks matched. Pass --stack <name> or run from a single-stack app.");
-  }
-  const routes = discoverRoutes(targetStacks);
-  if (routes.length === 0) {
-    throw new Error(
-      "No supported API routes were discovered. cdkd local start-api supports AWS::ApiGateway::* (REST v1), AWS::ApiGatewayV2::* (HTTP), and AWS::Lambda::Url (Function URL) with AWS_PROXY integrations only."
-    );
-  }
-  const routesWithAuth = attachAuthorizers(targetStacks, routes);
-  const lambdaIds = uniqueLambdaIds(routes, routesWithAuth);
   const overrides = readEnvOverridesFile(options.envVars);
   const debugPortBase = options.debugPortBase ? parseDebugPort(options.debugPortBase) : void 0;
-  const specs = /* @__PURE__ */ new Map();
+  const perLambdaConcurrency = parsePerLambdaConcurrency(options.perLambdaConcurrency);
   const inlineTmpDirs = /* @__PURE__ */ new Set();
   const layerTmpDirs = /* @__PURE__ */ new Set();
-  for (let i = 0; i < lambdaIds.length; i++) {
-    const logicalId = lambdaIds[i];
-    const spec = await buildContainerSpec({
-      logicalId,
-      stacks: targetStacks,
-      overrides,
-      assumeRole: options.assumeRole,
-      containerHost: options.containerHost,
-      ...debugPortBase !== void 0 && { debugPort: debugPortBase + i },
-      stsRegion: options.region ?? process.env["AWS_REGION"] ?? process.env["AWS_DEFAULT_REGION"],
-      inlineTmpDirs,
-      layerTmpDirs
+  const lastAssetPaths = { value: [] };
+  const authorizerCache = createAuthorizerCache();
+  const jwksCache = createJwksCache();
+  const jwksWarnedUrls = /* @__PURE__ */ new Set();
+  const synthesizeAndBuild = async () => {
+    logger.info("Synthesizing CDK app...");
+    const synthesizer = new Synthesizer();
+    const context = parseContextOptions(options.context);
+    const synthOpts = {
+      app: appCmd,
+      output: options.output,
+      ...options.region && { region: options.region },
+      ...options.profile && { profile: options.profile },
+      ...Object.keys(context).length > 0 && { context }
+    };
+    const { stacks } = await synthesizer.synthesize(synthOpts);
+    const targetStacks = pickTargetStacks(stacks, options.stack);
+    if (targetStacks.length === 0) {
+      throw new Error("No stacks matched. Pass --stack <name> or run from a single-stack app.");
+    }
+    const routes = discoverRoutes(targetStacks);
+    if (routes.length === 0) {
+      throw new Error(
+        "No supported API routes were discovered. cdkd local start-api supports AWS::ApiGateway::* (REST v1), AWS::ApiGatewayV2::* (HTTP), and AWS::Lambda::Url (Function URL) with AWS_PROXY integrations only."
+      );
+    }
+    const stageMap = /* @__PURE__ */ new Map();
+    for (const stack of targetStacks) {
+      const m = buildStageMap(stack.template, options.stage);
+      for (const [k, v] of m)
+        stageMap.set(k, v);
+    }
+    if (options.stage) {
+      const missingApis = /* @__PURE__ */ new Set();
+      for (const r of routes) {
+        if (!r.apiLogicalId)
+          continue;
+        if (!stageMap.has(r.apiLogicalId))
+          missingApis.add(r.apiLogicalId);
+      }
+      for (const apiId of missingApis) {
+        logger.warn(
+          `--stage '${options.stage}' did not match any Stage on API '${apiId}'; routes on that API will get stageVariables: null.`
+        );
+      }
+    }
+    attachStageContext(routes, stageMap);
+    const routesWithAuth = attachAuthorizers(targetStacks, routes);
+    const corsConfigByApiId = /* @__PURE__ */ new Map();
+    for (const stack of targetStacks) {
+      const m = buildCorsConfigByApiId(stack.template);
+      for (const [k, v] of m)
+        corsConfigByApiId.set(k, v);
+    }
+    const lambdaIds = uniqueLambdaIds(routes, routesWithAuth);
+    const specs = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lambdaIds.length; i++) {
+      const logicalId = lambdaIds[i];
+      const spec = await buildContainerSpec({
+        logicalId,
+        stacks: targetStacks,
+        overrides,
+        assumeRole: options.assumeRole,
+        containerHost: options.containerHost,
+        ...debugPortBase !== void 0 && { debugPort: debugPortBase + i },
+        stsRegion: options.region ?? process.env["AWS_REGION"] ?? process.env["AWS_DEFAULT_REGION"],
+        inlineTmpDirs,
+        layerTmpDirs
+      });
+      specs.set(logicalId, spec);
+    }
+    const distinctImages = /* @__PURE__ */ new Set();
+    for (const spec of specs.values()) {
+      distinctImages.add(resolveRuntimeImage(spec.lambda.runtime));
+    }
+    for (const image of distinctImages) {
+      await pullImage(image, options.pull === false);
+    }
+    return { routes: routesWithAuth, specs, corsConfigByApiId, stacks: targetStacks };
+  };
+  const buildPool = (specs) => {
+    const pool = createContainerPool(specs, {
+      perLambdaConcurrency,
+      skipPull: options.pull === false
     });
-    specs.set(logicalId, spec);
-  }
-  const distinctImages = /* @__PURE__ */ new Set();
-  for (const spec of specs.values()) {
-    distinctImages.add(resolveRuntimeImage(spec.lambda.runtime));
-  }
-  for (const image of distinctImages) {
-    await pullImage(image, options.pull === false);
-  }
-  const perLambdaConcurrency = parsePerLambdaConcurrency(options.perLambdaConcurrency);
-  const pool = createContainerPool(specs, {
-    perLambdaConcurrency,
-    skipPull: options.pull === false
-  });
+    Object.defineProperty(pool, "__cdkdSpecs", {
+      value: specs,
+      enumerable: false,
+      configurable: true
+    });
+    return pool;
+  };
+  const computeAssetPaths = (specs) => {
+    const assetPaths = /* @__PURE__ */ new Set();
+    for (const spec of specs.values()) {
+      assetPaths.add(spec.codeDir);
+    }
+    return [...assetPaths];
+  };
+  const initialMaterial = await synthesizeAndBuild();
+  const initialPool = buildPool(initialMaterial.specs);
+  lastAssetPaths.value = computeAssetPaths(initialMaterial.specs);
+  await prewarmJwks(initialMaterial.routes, jwksCache);
+  warnVpcConfigLambdas(initialMaterial.routes, initialMaterial.stacks ?? []);
   if (options.warm) {
-    logger.info(`Pre-warming ${specs.size} container(s)...`);
-    const handles = await Promise.allSettled([...specs.keys()].map((id) => pool.acquire(id)));
+    logger.info(`Pre-warming ${initialMaterial.specs.size} container(s)...`);
+    const handles = await Promise.allSettled(
+      [...initialMaterial.specs.keys()].map((id) => initialPool.acquire(id))
+    );
     for (const result of handles) {
       if (result.status === "fulfilled") {
-        pool.release(result.value);
+        initialPool.release(result.value);
       } else {
         logger.warn(
           `Pre-warm failed for one Lambda (cold start cost will apply on first request): ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`
@@ -73584,7 +75913,7 @@ async function localStartApiCommand(options) {
     }
   }
   let maxTimeoutSec = 0;
-  for (const spec of specs.values()) {
+  for (const spec of initialMaterial.specs.values()) {
     if (spec.lambda.timeoutSec > maxTimeoutSec)
       maxTimeoutSec = spec.lambda.timeoutSec;
   }
@@ -73593,14 +75922,13 @@ async function localStartApiCommand(options) {
   if (!Number.isFinite(port) || port < 0 || port > 65535) {
     throw new Error(`--port must be 0..65535 (got ${options.port}).`);
   }
-  const authorizerCache = createAuthorizerCache();
-  const jwksCache = createJwksCache();
-  const jwksWarnedUrls = /* @__PURE__ */ new Set();
-  await prewarmJwks(routesWithAuth, jwksCache);
-  warnVpcConfigLambdas(routesWithAuth, targetStacks);
+  const initialState = {
+    routes: initialMaterial.routes,
+    pool: initialPool,
+    corsConfigByApiId: initialMaterial.corsConfigByApiId
+  };
   const server = await startApiServer({
-    routes: routesWithAuth,
-    pool,
+    state: initialState,
     rieTimeoutMs,
     host: options.host,
     port,
@@ -73608,13 +75936,49 @@ async function localStartApiCommand(options) {
     jwksCache,
     jwksWarnedUrls
   });
-  printRouteTable(routes);
+  printRouteTable(initialMaterial.routes);
   logger.info(
     `Per-Lambda concurrency: ${perLambdaConcurrency} (override with --per-lambda-concurrency)`
   );
   process.stdout.write(`Server listening on http://${server.host}:${server.port}
 `);
   process.stdout.write("^C to stop and clean up containers.\n");
+  let watcher;
+  let orchestrator;
+  if (options.watch) {
+    orchestrator = createReloadOrchestrator({
+      synthesizeAndBuild,
+      buildPool,
+      setServerState: server.setServerState,
+      getServerState: server.getServerState
+    });
+    const initialWatchPaths = [options.output, ...lastAssetPaths.value];
+    watcher = createFileWatcher({
+      paths: initialWatchPaths,
+      onChange: () => {
+        if (!orchestrator)
+          return;
+        logger.info("Detected file change; reloading...");
+        void orchestrator.reload().then((result) => {
+          if (result.ok && watcher && result.newState) {
+            const taggedSpecs = result.newState.pool.__cdkdSpecs;
+            if (taggedSpecs) {
+              lastAssetPaths.value = computeAssetPaths(taggedSpecs);
+            }
+            watcher.update([options.output, ...lastAssetPaths.value]);
+            if (result.added.length > 0 || result.removed.length > 0) {
+              printRouteTable(result.newState.routes);
+            }
+          }
+        }).catch((err) => {
+          logger.warn(
+            `Reload failed: ${err instanceof Error ? err.message : String(err)}. Keeping previous version.`
+          );
+        });
+      }
+    });
+    logger.info(`Watching ${options.output} (and ${lastAssetPaths.value.length} asset dir(s))`);
+  }
   let shuttingDown = false;
   let forceExitArmed = false;
   const shutdown = async (signal, exitCode) => {
@@ -73630,13 +75994,20 @@ async function localStartApiCommand(options) {
     }
     shuttingDown = true;
     logger.info(`Received ${signal}, shutting down...`);
+    if (watcher) {
+      try {
+        await watcher.close();
+      } catch (err) {
+        logger.warn(`watcher.close() failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
     try {
       await server.close();
     } catch (err) {
       logger.warn(`server.close() failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      await pool.dispose();
+      await server.getServerState().pool.dispose();
     } catch (err) {
       logger.warn(`pool.dispose() failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -73895,7 +76266,8 @@ function resolveAssetCodePath2(stack, logicalId, resource) {
   return path.isAbsolute(assetPath) ? assetPath : path.resolve(cdkOutDir, assetPath);
 }
 function printRouteTable(routes) {
-  const sorted = [...routes].sort((a, b) => {
+  const flat = routes.map((r) => r.route);
+  const sorted = [...flat].sort((a, b) => {
     if (a.pathPattern !== b.pathPattern)
       return a.pathPattern.localeCompare(b.pathPattern);
     return a.method.localeCompare(b.method);
@@ -74049,6 +76421,16 @@ function createLocalStartApiCommand() {
       "--assume-role <arn-or-pair>",
       "Assume the Lambda's execution role and forward STS-issued temp creds. Bare <arn> = global default; <LogicalId>=<arn> = per-Lambda override (repeatable). Per-Lambda > global > unset (developer creds passed through)."
     ).argParser((raw, prev) => parseAssumeRoleToken(raw, prev))
+  ).addOption(
+    new Option7(
+      "--watch",
+      "Hot-reload: re-synth + re-discover routes when cdk.out/ or asset directories change. Off by default; the server keeps the previous version serving when synth fails mid-reload."
+    ).default(false)
+  ).addOption(
+    new Option7(
+      "--stage <name>",
+      "Select an API Gateway Stage by its 'StageName'. Default: the first Stage attached to each API. Drives event.stageVariables for both REST v1 and HTTP API v2. NOTE: For HTTP API v2 routes, requestContext.stage is always '$default' regardless of this flag (AWS-side limitation \u2014 HTTP API only exposes one stage to the integration event); only event.stageVariables is affected for v2 routes. For REST v1 routes the selected StageName is also threaded into requestContext.stage."
+    )
   ).action(withErrorHandling(localStartApiCommand));
   [...commonOptions, ...appOptions, ...contextOptions].forEach((opt) => startApi.addOption(opt));
   startApi.addOption(deprecatedRegionOption);
@@ -74329,7 +76711,7 @@ async function resolveLocalBuildPlan(lambda) {
   const manifestPath = lambda.stack.assetManifestPath;
   if (!manifestPath)
     return void 0;
-  const cdkOutDir = dirname3(manifestPath);
+  const cdkOutDir = dirname5(manifestPath);
   const loader = new AssetManifestLoader();
   const manifest = await loader.loadManifest(cdkOutDir, lambda.stack.stackName);
   if (!manifest)
@@ -74633,7 +77015,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command16();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.74.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.75.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());
@@ -74654,4 +77036,9 @@ main().catch((error) => {
   console.error("Fatal error:", error);
   process.exit(1);
 });
+/*! Bundled license information:
+
+chokidar/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=cli.js.map