@postman-cse/onboarding-bootstrap 2.9.4 → 2.9.6

package/dist/action.cjs

@@ -99989,11 +99989,11 @@ var require_valid = __commonJS({
 var require_clean = __commonJS({
   "node_modules/postman-collection/node_modules/semver/functions/clean.js"(exports2, module2) {
     var parse10 = require_parse6();
-    var clean = (version, options) => {
+    var clean2 = (version, options) => {
       const s = parse10(version.trim().replace(/^[=v]+/, ""), options);
       return s ? s.version : null;
     };
-    module2.exports = clean;
+    module2.exports = clean2;
   }
 });
 
@@ -101304,7 +101304,7 @@ var require_semver2 = __commonJS({
     var identifiers = require_identifiers();
     var parse10 = require_parse6();
     var valid = require_valid();
-    var clean = require_clean();
+    var clean2 = require_clean();
     var inc = require_inc();
     var diff = require_diff();
     var major = require_major();
@@ -101342,7 +101342,7 @@ var require_semver2 = __commonJS({
     module2.exports = {
       parse: parse10,
       valid,
-      clean,
+      clean: clean2,
       inc,
       diff,
       major,
@@ -256197,8 +256197,8 @@ function getIDToken(aud) {
 }
 
 // src/index.ts
-var import_node_crypto5 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
+var import_node_crypto6 = require("node:crypto");
+var import_node_fs6 = require("node:fs");
 var path9 = __toESM(require("node:path"), 1);
 var import_yaml4 = __toESM(require_dist(), 1);
 
@@ -256306,6 +256306,12 @@ var bootstrapActionContract = {
       default: "",
       allowedValues: ["3.0", "3.1"]
     },
+    "preserve-oas30-type-null": {
+      description: "Opt-in compatibility mode for legacy OpenAPI 3.0 oneOf schemas that pair a normal schema with type: null. The original source bytes are uploaded unchanged while an internal nullable view is used for validation and generated artifacts.",
+      required: false,
+      default: "false",
+      allowedValues: ["true", "false"]
+    },
     "breaking-change-mode": {
       description: "OpenAPI breaking-change comparison mode.",
       required: false,
@@ -256362,6 +256368,20 @@ var bootstrapActionContract = {
       default: "warn",
       allowedValues: ["enforce", "warn"]
     },
+    "branch-strategy": {
+      description: "Branch-aware sync strategy. legacy (default) keeps branch-blind behavior; publish-gate restricts canonical writes to the canonical branch and runs credential-free static validation on other branches; preview additionally maintains suffixed per-branch preview asset sets.",
+      required: false,
+      default: "legacy",
+      allowedValues: ["legacy", "preview", "publish-gate"]
+    },
+    "canonical-branch": {
+      description: "Explicit canonical branch (the sole writer of canonical assets). Defaults to the provider-resolved default branch; required on providers without a default-branch variable (Bitbucket, Azure DevOps) when branch-strategy is not legacy.",
+      required: false
+    },
+    "channels": {
+      description: 'Comma-separated channel map for long-lived promotion branches, e.g. "develop=DEV, staging=STAGE, release/*=RC". Channel branches maintain prefix-named parallel asset sets and never mutate canonical assets.',
+      required: false
+    },
     "integration-backend": {
       description: "Integration backend for downstream workspace connectivity.",
       required: false,
@@ -256431,6 +256451,21 @@ var bootstrapActionContract = {
     },
     "breaking-change-summary-json": {
       description: "JSON summary of the OpenAPI breaking-change check."
+    },
+    "sync-status": {
+      description: "Branch-aware sync status: synced (canonical/channel/preview write ran), skipped-branch-gate (gated run, credential-free validation only), or empty under branch-strategy legacy."
+    },
+    "branch-decision": {
+      description: "Serialized BranchDecision JSON for downstream actions (also exported as POSTMAN_BRANCH_DECISION)."
+    },
+    "spec-version-tag": {
+      description: "Native Spec Hub version tag applied on this canonical publish (tag-per-publish), empty when tagging was skipped (no-op sync, non-canonical run, or legacy client)."
+    },
+    "spec-version-url": {
+      description: "Reserved for the repo-sync finalizer; bootstrap does not tag before complete onboarding."
+    },
+    "spec-content-changed": {
+      description: "Whether bootstrap changed canonical spec content; repo-sync uses this to skip native version tags on no-op syncs."
     }
   },
   retainedBehavior: [
@@ -257557,6 +257592,15 @@ function assertSupportedLocalViewContract(node, options) {
 }
 
 // src/lib/postman/additional-collections.ts
+var RESOURCES_STATE_VERSION = 2;
+var SUPPORTED_STATE_VERSIONS = /* @__PURE__ */ new Set([1, RESOURCES_STATE_VERSION]);
+var StateUnreadableError = class extends Error {
+  code = "CONTRACT_STATE_UNREADABLE";
+  constructor(message) {
+    super(`CONTRACT_STATE_UNREADABLE: ${message}`);
+    this.name = "StateUnreadableError";
+  }
+};
 var ADDITIONAL_COLLECTION_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".yaml", ".yml"]);
 var POSTMAN_COLLECTION_V21_SCHEMA_FRAGMENT = "/collection/v2.1.0/collection.json";
 var V3_DEFINITION_PATH = import_node_path2.default.join(".resources", "definition.yaml");
@@ -257612,16 +257656,46 @@ function resourcesStatePath() {
   return import_node_path2.default.join(workspaceRootForLocalInputs(), RESOURCES_PATH);
 }
 function readResourcesState() {
+  let raw;
   try {
-    return (0, import_yaml.parse)((0, import_node_fs2.readFileSync)(resourcesStatePath(), "utf8"));
+    raw = (0, import_node_fs2.readFileSync)(resourcesStatePath(), "utf8");
   } catch {
     return null;
   }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(raw);
+  } catch (error2) {
+    throw new StateUnreadableError(
+      `.postman/resources.yaml exists but is not parseable YAML (${error2 instanceof Error ? error2.message : String(error2)}). Fix or delete the file; refusing to treat tracked state as absent.`
+    );
+  }
+  if (parsed === null || parsed === void 0) {
+    return null;
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new StateUnreadableError(
+      ".postman/resources.yaml exists but does not contain a YAML mapping. Fix or delete the file; refusing to treat tracked state as absent."
+    );
+  }
+  const state = parsed;
+  if (state.version !== void 0 && !SUPPORTED_STATE_VERSIONS.has(Number(state.version))) {
+    throw new StateUnreadableError(
+      `.postman/resources.yaml declares unsupported state version ${String(state.version)} (supported: 1, ${RESOURCES_STATE_VERSION}). Upgrade the action or fix the file.`
+    );
+  }
+  if (state.canonical && !state.cloudResources) {
+    state.cloudResources = { ...state.canonical };
+  }
+  return state;
 }
 function writeResourcesState(state) {
   const target = resourcesStatePath();
   (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(target), { recursive: true });
-  (0, import_node_fs2.writeFileSync)(target, (0, import_yaml.stringify)(state), "utf8");
+  const canonical = state.cloudResources ?? state.canonical ?? {};
+  const persisted = { ...state, version: RESOURCES_STATE_VERSION, canonical };
+  delete persisted.cloudResources;
+  (0, import_node_fs2.writeFileSync)(target, (0, import_yaml.stringify)(persisted), "utf8");
 }
 function findCloudResourceId(map, matcher) {
   if (!map) {
@@ -257631,7 +257705,7 @@ function findCloudResourceId(map, matcher) {
   return match?.[1];
 }
 function findExistingAdditionalCollectionId(resourcesState, resourcePath) {
-  return resourcesState?.cloudResources?.additionalCollections?.[resourcePath] ?? resourcesState?.cloudResources?.collections?.[resourcePath];
+  return resourcesState?.canonical?.additionalCollections?.[resourcePath] ?? resourcesState?.canonical?.collections?.[resourcePath] ?? resourcesState?.cloudResources?.additionalCollections?.[resourcePath] ?? resourcesState?.cloudResources?.collections?.[resourcePath];
 }
 function resolveAdditionalCollectionsDir(directoryInput) {
   const workspaceRoot = workspaceRootForLocalInputs();
@@ -258633,6 +258707,8 @@ var BifrostInternalIntegrationAdapter = class _BifrostInternalIntegrationAdapter
    * endpoint aborts rather than blocking the run forever. */
   static REQUEST_TIMEOUT_MS = 3e4;
   static POSTMAN_APP_VERSION_URL = `https://dl.pstmn.io/update/status?currentVersion=${_BifrostInternalIntegrationAdapter.MINIMUM_POSTMAN_APP_VERSION}&platform=osx_arm64`;
+  /** Concurrent dual-trigger previews share one spec; peer sync holds a 423 lock. */
+  static SYNC_LOCKED_MAX_RETRIES = 6;
   accessToken;
   tokenProvider;
   appVersionPromise;
@@ -258641,6 +258717,7 @@ var BifrostInternalIntegrationAdapter = class _BifrostInternalIntegrationAdapter
   gatewayBaseUrl;
   orgMode;
   secretMasker;
+  sleep;
   teamId;
   constructor(options) {
     this.accessToken = String(options.accessToken || "").trim();
@@ -258654,6 +258731,7 @@ var BifrostInternalIntegrationAdapter = class _BifrostInternalIntegrationAdapter
     ).replace(/\/+$/, "");
     this.orgMode = options.orgMode ?? false;
     this.secretMasker = options.secretMasker ?? createSecretMasker([this.accessToken]);
+    this.sleep = options.sleep ?? ((delayMs) => new Promise((resolve5) => setTimeout(resolve5, delayMs)));
     this.teamId = String(options.teamId || "").trim();
   }
   configureTeamContext(teamId, orgMode) {
@@ -258860,55 +258938,72 @@ var BifrostInternalIntegrationAdapter = class _BifrostInternalIntegrationAdapter
     if (collections.length === 0) {
       return;
     }
-    const response = await this.proxyRequest(
-      "specification",
-      "put",
-      `/specifications/${specificationId}/collections`,
-      collections.map((collection) => ({
-        collectionId: collection.collectionId,
-        ...collection.syncOptions ? { syncOptions: collection.syncOptions } : {}
-      }))
-    );
-    if (response.ok) {
-      return;
+    const body2 = collections.map((collection) => ({
+      collectionId: collection.collectionId,
+      ...collection.syncOptions ? { syncOptions: collection.syncOptions } : {}
+    }));
+    for (let lockedAttempt = 0; ; lockedAttempt += 1) {
+      const response = await this.proxyRequest(
+        "specification",
+        "put",
+        `/specifications/${specificationId}/collections`,
+        body2
+      );
+      if (response.ok) {
+        return;
+      }
+      const httpErr = await HttpError.fromResponse(response, {
+        method: "POST",
+        requestHeaders: {
+          "Content-Type": "application/json",
+          "x-access-token": this.currentToken(),
+          ...this.teamId && this.orgMode ? { "x-entity-team-id": this.teamId } : {}
+        },
+        secretValues: [this.currentToken()],
+        url: `${this.bifrostBaseUrl}/ws/proxy`
+      });
+      if (httpErr.status === 423 && lockedAttempt < _BifrostInternalIntegrationAdapter.SYNC_LOCKED_MAX_RETRIES) {
+        await this.sleep(2e3 * Math.pow(2, lockedAttempt));
+        continue;
+      }
+      const advised = adviseFromHttpError(
+        httpErr,
+        this.adviceContext("collection-to-specification linking")
+      );
+      throw advised ?? httpErr;
     }
-    const httpErr = await HttpError.fromResponse(response, {
-      method: "POST",
-      requestHeaders: {
-        "Content-Type": "application/json",
-        "x-access-token": this.currentToken(),
-        ...this.teamId && this.orgMode ? { "x-entity-team-id": this.teamId } : {}
-      },
-      secretValues: [this.currentToken()],
-      url: `${this.bifrostBaseUrl}/ws/proxy`
-    });
-    const advised = adviseFromHttpError(
-      httpErr,
-      this.adviceContext("collection-to-specification linking")
-    );
-    throw advised ?? httpErr;
   }
   async syncCollection(specificationId, collectionId) {
-    const response = await this.proxyRequest(
-      "specification",
-      "post",
-      `/specifications/${specificationId}/collections/${collectionId}/sync`
-    );
-    if (response.ok) {
-      return;
+    for (let lockedAttempt = 0; ; lockedAttempt += 1) {
+      const response = await this.proxyRequest(
+        "specification",
+        "post",
+        `/specifications/${specificationId}/collections/${collectionId}/sync`
+      );
+      if (response.ok) {
+        return;
+      }
+      const bodyText = await response.clone().text().catch(() => "");
+      if (response.status === 400 && /already in sync/i.test(bodyText)) {
+        return;
+      }
+      const httpErr = await HttpError.fromResponse(response, {
+        method: "POST",
+        requestHeaders: {
+          "Content-Type": "application/json",
+          "x-access-token": this.currentToken(),
+          ...this.teamId && this.orgMode ? { "x-entity-team-id": this.teamId } : {}
+        },
+        secretValues: [this.currentToken()],
+        url: `${this.bifrostBaseUrl}/ws/proxy`
+      });
+      if (httpErr.status === 423 && lockedAttempt < _BifrostInternalIntegrationAdapter.SYNC_LOCKED_MAX_RETRIES) {
+        await this.sleep(2e3 * Math.pow(2, lockedAttempt));
+        continue;
+      }
+      const advised = adviseFromHttpError(httpErr, this.adviceContext("collection sync"));
+      throw advised ?? httpErr;
     }
-    const httpErr = await HttpError.fromResponse(response, {
-      method: "POST",
-      requestHeaders: {
-        "Content-Type": "application/json",
-        "x-access-token": this.currentToken(),
-        ...this.teamId && this.orgMode ? { "x-entity-team-id": this.teamId } : {}
-      },
-      secretValues: [this.currentToken()],
-      url: `${this.bifrostBaseUrl}/ws/proxy`
-    });
-    const advised = adviseFromHttpError(httpErr, this.adviceContext("collection sync"));
-    throw advised ?? httpErr;
   }
   async getWorkspaceGitRepoUrl(workspaceId) {
     const response = await this.proxyRequest(
@@ -259313,6 +259408,18 @@ async function retry(operation, options = {}) {
   }
   throw new Error("Retry exhausted without returning or throwing");
 }
+function fullJitterDelayMs(attempt, baseMs, capMs, random = Math.random) {
+  const ceiling = Math.min(capMs, baseMs * 2 ** Math.max(0, attempt));
+  return Math.floor(random() * Math.max(0, ceiling));
+}
+function parseRetryAfterMs2(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const when = Date.parse(trimmed);
+  if (!Number.isNaN(when)) return Math.max(0, when - Date.now());
+  return void 0;
+}
 
 // src/lib/postman/postman-ec-client.ts
 var EC_WRITE_MAX_ATTEMPTS = 3;
@@ -263926,6 +264033,12 @@ var BOOTSTRAP_BARE_UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9
 function isMissingPatchValueError(error2) {
   return error2 instanceof HttpError && error2.status === 400 && error2.responseBody.includes("Remove operation must point to an existing value");
 }
+function isRejectedPatchError(error2) {
+  return error2 instanceof HttpError && error2.status === 400 && /REJECTED_PATCH|must update at least one/i.test(
+    `${error2.message}
+${error2.responseBody ?? ""}`
+  );
+}
 function canonicalize(value) {
   if (Array.isArray(value)) return value.map(canonicalize);
   if (value && typeof value === "object") {
@@ -263989,6 +264102,7 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
   static DEFAULT_GENERATION_POLL_DELAY_MS = 2e3;
   gateway;
   sleep;
+  random;
   generationPollAttempts;
   generationPollDelayMs;
   createIdentity;
@@ -263996,6 +264110,7 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     this.gateway = options.gateway;
     this.createIdentity = options.createIdentity ?? import_node_crypto2.randomUUID;
     this.sleep = options.sleep ?? ((delayMs) => new Promise((resolve5) => setTimeout(resolve5, delayMs)));
+    this.random = options.random ?? Math.random;
     this.generationPollAttempts = resolvePollBudget(
       options.generationPollAttempts,
       process.env.POSTMAN_GENERATION_POLL_ATTEMPTS,
@@ -264053,6 +264168,16 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     if (openapiVersion !== "3.0" && openapiVersion !== "3.1") {
       throw new Error(`uploadSpec: unsupported openapiVersion "${openapiVersion}". Expected '3.0' or '3.1'.`);
     }
+    const before = await this.findSpecificationsByExactName(workspaceId, projectName);
+    const existing = adoptExactMatch(
+      `specification:${workspaceId}:${projectName}`,
+      before,
+      (entry) => entry.id
+    );
+    if (existing) {
+      await this.updateSpec(existing.id, specContent, workspaceId);
+      return existing.id;
+    }
     const specType = openapiVersion === "3.1" ? "OPENAPI:3.1" : "OPENAPI:3.0";
     let created;
     try {
@@ -264077,10 +264202,49 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
       if (!match) throw error2;
       created = { data: { id: match.id } };
     }
-    const specId = String(asRecord8(created?.data)?.id ?? created?.id ?? "").trim();
+    let specId = String(asRecord8(created?.data)?.id ?? created?.id ?? "").trim();
     if (!specId) {
       throw new Error("Spec upload did not return an ID");
     }
+    let matches = await this.findSpecificationsByExactName(workspaceId, projectName);
+    if (before.length === 0 && matches.length <= 1) {
+      await this.sleep(1e3);
+      const settled = await this.findSpecificationsByExactName(workspaceId, projectName);
+      if (settled.length > 0) matches = settled;
+    }
+    if (matches.length > 1 && before.length === 0) {
+      for (const duplicate of matches.slice(1)) {
+        try {
+          await this.deleteSpecification(duplicate.id);
+        } catch (error2) {
+          if (!(error2 instanceof HttpError && error2.status === 404)) throw error2;
+        }
+      }
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        matches = await this.findSpecificationsByExactName(workspaceId, projectName);
+        if (matches.length <= 1) break;
+        await this.sleep(250 * (attempt + 1));
+      }
+      const converged = adoptExactMatch(
+        `specification:${workspaceId}:${projectName}`,
+        matches,
+        (entry) => entry.id
+      );
+      if (!converged) {
+        throw new Error(`Concurrent specification create for ${projectName} did not converge`);
+      }
+      specId = converged.id;
+      if (specId !== String(asRecord8(created?.data)?.id ?? created?.id ?? "").trim()) {
+        await this.updateSpec(specId, specContent, workspaceId);
+      }
+    } else {
+      const verified = adoptExactMatch(
+        `specification:${workspaceId}:${projectName}`,
+        matches,
+        (entry) => entry.id
+      );
+      if (verified) specId = verified.id;
+    }
     await this.gateway.requestJson({
       service: "specification",
       method: "get",
@@ -264088,6 +264252,14 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     });
     return specId;
   }
+  async deleteSpecification(specId) {
+    await this.gateway.requestJson({
+      service: "specification",
+      method: "delete",
+      path: `/specifications/${specId}`,
+      retry: "none"
+    });
+  }
   async findSpecificationsByExactName(workspaceId, name) {
     const response = await this.gateway.requestJson({
       service: "specification",
@@ -264151,6 +264323,41 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
       return void 0;
     }
   }
+  /**
+   * Native Spec Hub version tags (branch-aware sync P3.5). Tags attach to the
+   * LATEST changelog group; the backend 409s when that group is already tagged
+   * (VersionControlService). Callers handle 409 as idempotent-by-group.
+   */
+  async tagSpecVersion(specId, name) {
+    const trimmed = name.trim().slice(0, 255);
+    const created = await this.gateway.requestJson({
+      service: "specification",
+      method: "post",
+      path: `/specifications/${specId}/tags`,
+      retry: "none",
+      body: { name: trimmed }
+    });
+    const record = asRecord8(created?.data) ?? created ?? {};
+    return {
+      id: String(record.id ?? "").trim(),
+      name: String(record.name ?? trimmed).trim()
+    };
+  }
+  /** List a spec's native version tags (newest first per backend ordering). */
+  async listSpecVersionTags(specId) {
+    const response = await this.gateway.requestJson({
+      service: "specification",
+      method: "get",
+      path: `/specifications/${specId}/tags`,
+      query: { limit: "50" }
+    });
+    const entries = Array.isArray(response?.data) ? response.data : [];
+    return entries.map((value) => asRecord8(value)).filter((value) => value !== null).map((value) => ({
+      id: String(value.id ?? "").trim(),
+      // listTags returns `message`; createTag returns `name`. Accept both.
+      name: String(value.name ?? value.message ?? "").trim()
+    })).filter((value) => value.id || value.name);
+  }
   /** Resolve a specification's ROOT file uuid via the files list. */
   async resolveRootFileId(specId) {
     const files = await this.gateway.requestJson({
@@ -264170,79 +264377,182 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
    */
   async generateCollection(specId, projectName, prefix, folderStrategy, nestedFolderHierarchy, requestNameSource) {
     const name = [prefix.trim(), projectName.trim()].filter(Boolean).join(" ");
-    const submittedName = `${name} [bootstrap:${this.createIdentity()}]`;
-    const body2 = {
-      name: submittedName,
-      options: {
-        requestNameSource,
-        folderStrategy,
-        ...folderStrategy === "Tags" ? { nestedFolderHierarchy } : {}
-      }
-    };
     const before = await this.listGeneratedCollectionRefs(specId);
-    let taskId;
-    try {
-      taskId = await this.postGenerationWithLockRetry(specId, body2);
-    } catch (error2) {
-      if (!isAmbiguousTransportError(error2)) throw error2;
-      const beforeIds2 = new Set(before.map((entry) => entry.id));
-      const appeared2 = (await this.listGeneratedCollectionRefs(specId)).filter(
-        (entry) => !beforeIds2.has(entry.id)
-      );
-      const exactAppeared = await this.filterGeneratedCollectionsByExactName(
-        appeared2,
+    const existing = adoptExactMatch(
+      `generated-collection:${specId}:${name}`,
+      await this.filterGeneratedCollectionsByExactName(before, name),
+      (entry) => entry.id
+    );
+    if (existing) return this.convergeGeneratedCollections(specId, name, existing.id);
+    let lastError;
+    for (let taskAttempt = 0; taskAttempt < 2; taskAttempt += 1) {
+      const submittedName = `${name} [bootstrap:${this.createIdentity()}]`;
+      const body2 = {
+        name: submittedName,
+        options: {
+          requestNameSource,
+          folderStrategy,
+          ...folderStrategy === "Tags" ? { nestedFolderHierarchy } : {}
+        }
+      };
+      let taskId;
+      try {
+        const generation = await this.postGenerationWithLockRetry(specId, body2, name);
+        if (generation.adoptedId) {
+          return this.convergeGeneratedCollections(specId, name, generation.adoptedId);
+        }
+        taskId = generation.taskId ?? "";
+      } catch (error2) {
+        if (!isAmbiguousTransportError(error2)) throw error2;
+        const beforeIds2 = new Set(before.map((entry) => entry.id));
+        const appeared2 = (await this.listGeneratedCollectionRefs(specId)).filter(
+          (entry) => !beforeIds2.has(entry.id)
+        );
+        const exactAppeared = await this.filterGeneratedCollectionsByExactName(
+          appeared2,
+          submittedName
+        );
+        const match = adoptExactMatch(
+          `generated-collection:${specId}:${submittedName}`,
+          exactAppeared,
+          (entry) => entry.id
+        );
+        if (!match) throw error2;
+        await this.renameGeneratedCollection(match.id, name);
+        return this.convergeGeneratedCollections(specId, name, match.id);
+      }
+      let taskFailed = false;
+      if (taskId) {
+        for (let attempt = 0; attempt < this.generationPollAttempts; attempt += 1) {
+          await this.sleep(this.generationPollDelayMs);
+          const task = await this.gateway.requestJson({
+            service: "specification",
+            method: "get",
+            path: "/tasks",
+            query: { entityId: specId, entityType: "specification", type: "collection-generation" }
+          });
+          const status = String(asRecord8(task?.data)?.[taskId] ?? "").toLowerCase();
+          if (status === "failed" || status === "error") {
+            taskFailed = true;
+            lastError = new Error(`Collection generation task failed for ${prefix}`);
+            break;
+          }
+          if (status && status !== "in-progress" && status !== "pending" && status !== "queued") {
+            break;
+          }
+          if (attempt === this.generationPollAttempts - 1) {
+            throw new Error(`Collection generation timed out for ${prefix}`);
+          }
+        }
+      }
+      if (taskFailed) {
+        await this.sleep(1e3 * (taskAttempt + 1));
+        continue;
+      }
+      const beforeIds = new Set(before.map((entry) => entry.id));
+      const after = await this.listGeneratedCollectionRefs(specId);
+      const appeared = after.filter((entry) => !beforeIds.has(entry.id));
+      const candidates = await this.filterGeneratedCollectionsByExactName(
+        appeared,
         submittedName
       );
-      const match = adoptExactMatch(
+      const uid = adoptExactMatch(
         `generated-collection:${specId}:${submittedName}`,
-        exactAppeared,
+        candidates,
         (entry) => entry.id
-      );
-      if (!match) throw error2;
-      await this.renameGeneratedCollection(match.id, name);
-      return match.id;
+      )?.id;
+      if (!uid) {
+        throw new Error(`Collection generation did not yield a collection uid for ${prefix}`);
+      }
+      await this.renameGeneratedCollection(uid, name);
+      return this.convergeGeneratedCollections(specId, name, uid);
     }
-    if (taskId) {
-      for (let attempt = 0; attempt < this.generationPollAttempts; attempt += 1) {
-        await this.sleep(this.generationPollDelayMs);
-        const task = await this.gateway.requestJson({
-          service: "specification",
-          method: "get",
-          path: "/tasks",
-          query: { entityId: specId, entityType: "specification", type: "collection-generation" }
-        });
-        const status = String(asRecord8(task?.data)?.[taskId] ?? "").toLowerCase();
-        if (status === "failed" || status === "error") {
-          throw new Error(`Collection generation task failed for ${prefix}`);
-        }
-        if (status && status !== "in-progress" && status !== "pending" && status !== "queued") {
-          break;
-        }
-        if (attempt === this.generationPollAttempts - 1) {
-          throw new Error(`Collection generation timed out for ${prefix}`);
+    throw lastError ?? new Error(`Collection generation task failed for ${prefix}`);
+  }
+  /**
+   * Re-elect the durable generated collection for a final name. Call after
+   * concurrent dual-trigger generates and before description/inject/tag so a
+   * peer orphan-sweep cannot leave this runner holding a deleted id.
+   */
+  async adoptGeneratedCollection(specId, projectName, prefix, preferredId = "") {
+    const name = [prefix.trim(), projectName.trim()].filter(Boolean).join(" ");
+    return this.convergeGeneratedCollections(specId, name, preferredId);
+  }
+  /**
+   * Concurrent dual-trigger previews can each generate+rename the same final
+   * collection identity. Elect the stable lowest-id winner.
+   *
+   * Losers only delete *their own* preferred collection (never a peer's still-
+   * in-use id). Winners wait briefly for peers to self-delete, then clean any
+   * leftover same-identity orphans (temps + extra finals).
+   */
+  async convergeGeneratedCollections(specId, finalName, preferredId) {
+    const tempPrefix = `${finalName} [bootstrap:`;
+    const hydrate = async () => {
+      const linked = await this.listGeneratedCollectionRefs(specId);
+      return Promise.all(
+        linked.map(async (entry) => {
+          if (entry.name) return { id: entry.id, name: entry.name };
+          try {
+            const collection = await this.gateway.requestJson({
+              service: "collection",
+              method: "get",
+              path: `/v3/collections/${this.bareModelId(entry.id)}`
+            });
+            return {
+              id: entry.id,
+              name: String(asRecord8(collection?.data)?.name ?? "").trim()
+            };
+          } catch (error2) {
+            if (error2 instanceof HttpError && error2.status === 404) {
+              return { id: entry.id, name: "" };
+            }
+            throw error2;
+          }
+        })
+      );
+    };
+    const selectSameIdentity = (entries) => entries.filter(
+      (entry) => entry.name === finalName || entry.name.startsWith(tempPrefix)
+    ).sort((a, b) => a.id.localeCompare(b.id));
+    let sameIdentity = selectSameIdentity(await hydrate());
+    if (sameIdentity.length === 0) return preferredId;
+    if (sameIdentity.length === 1) {
+      await this.sleep(1e3);
+      sameIdentity = selectSameIdentity(await hydrate());
+      if (sameIdentity.length === 0) return preferredId;
+    }
+    const winner = sameIdentity[0];
+    if (winner.name !== finalName) {
+      await this.renameGeneratedCollection(winner.id, finalName);
+    }
+    if (preferredId && preferredId !== winner.id) {
+      const own = sameIdentity.find((entry) => entry.id === preferredId);
+      if (own) {
+        try {
+          await this.deleteCollection(preferredId);
+        } catch (error2) {
+          if (!(error2 instanceof HttpError && error2.status === 404)) throw error2;
         }
       }
+      return winner.id;
     }
-    const beforeIds = new Set(before.map((entry) => entry.id));
-    const after = await this.listGeneratedCollectionRefs(specId);
-    const appeared = after.filter((entry) => !beforeIds.has(entry.id));
-    const candidates = await this.filterGeneratedCollectionsByExactName(
-      appeared,
-      submittedName
-    );
-    const uid = adoptExactMatch(
-      `generated-collection:${specId}:${submittedName}`,
-      candidates,
-      (entry) => entry.id
-    )?.id;
-    if (!uid) {
-      throw new Error(`Collection generation did not yield a collection uid for ${prefix}`);
+    if (sameIdentity.length > 1) {
+      await this.sleep(1500);
+      sameIdentity = selectSameIdentity(await hydrate());
+      for (const duplicate of sameIdentity) {
+        if (duplicate.id === winner.id) continue;
+        try {
+          await this.deleteCollection(duplicate.id);
+        } catch (error2) {
+          if (!(error2 instanceof HttpError && error2.status === 404)) throw error2;
+        }
+      }
     }
-    await this.renameGeneratedCollection(uid, name);
-    return uid;
+    return winner.id;
   }
   /** POST the generation request, retrying a 423-locked spec; returns the task id. */
-  async postGenerationWithLockRetry(specId, body2) {
+  async postGenerationWithLockRetry(specId, body2, finalName) {
     for (let lockedAttempt = 0; ; lockedAttempt += 1) {
       try {
         const created = await this.gateway.requestJson({
@@ -264252,13 +264562,22 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
           retry: "none",
           body: body2
         });
-        return String(asRecord8(created?.data)?.taskId ?? "").trim();
+        return { taskId: String(asRecord8(created?.data)?.taskId ?? "").trim() };
       } catch (error2) {
         const locked = error2 instanceof HttpError && error2.status === 423;
         if (!locked || lockedAttempt >= _PostmanGatewayAssetsClient.GENERATION_LOCKED_MAX_RETRIES) {
           throw error2;
         }
         await this.sleep(5e3 * Math.pow(2, lockedAttempt));
+        const adopted = adoptExactMatch(
+          `generated-collection:${specId}:${finalName}`,
+          await this.filterGeneratedCollectionsByExactName(
+            await this.listGeneratedCollectionRefs(specId),
+            finalName
+          ),
+          (entry) => entry.id
+        );
+        if (adopted) return { adoptedId: adopted.id };
       }
     }
   }
@@ -264295,14 +264614,24 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     return hydrated.filter((entry) => entry.name === expectedName);
   }
   async renameGeneratedCollection(collectionId, name) {
-    await this.gateway.requestJson({
-      service: "collection",
-      method: "patch",
-      path: `/v3/collections/${this.bareModelId(collectionId)}`,
-      // Replacing a generated collection's name with the same value is idempotent.
-      retry: "safe",
-      body: [{ op: "replace", path: "/name", value: name }]
-    });
+    try {
+      await this.gateway.requestJson({
+        service: "collection",
+        method: "patch",
+        path: `/v3/collections/${this.bareModelId(collectionId)}`,
+        // Replacing a generated collection's name with the same value is idempotent.
+        retry: "safe",
+        body: [{ op: "replace", path: "/name", value: name }]
+      });
+    } catch (error2) {
+      if (error2 instanceof HttpError && error2.status === 400 && /must update at least one|REJECTED_PATCH/i.test(
+        `${error2.message}
+${error2.responseBody ?? ""}`
+      )) {
+        return;
+      }
+      throw error2;
+    }
   }
   /**
    * Create a team-visible workspace through the gateway workspaces service.
@@ -264556,7 +264885,7 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
         if (!retriable || attempt === maxAttempts - 1) {
           throw error2;
         }
-        await this.sleep(Math.min(2e3, 300 * 2 ** attempt));
+        await this.sleep(fullJitterDelayMs(attempt, 300, 2e3, this.random));
       }
     }
   }
@@ -264577,6 +264906,7 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
       service: "tagging",
       method: "put",
       path: `/v1/tags/collections/${collectionUid}`,
+      retry: "safe",
       body: { tags: normalized.map((slug) => ({ slug })) }
     });
   }
@@ -264806,14 +265136,19 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
       { type: "afterResponse", code: exec2.join("\n"), language: "text/javascript" }
     ];
     for (const script of plan.scripts) {
-      await this.gateway.requestJson({
-        service: "collection",
-        method: "patch",
-        path: `/v3/collections/${cid}/items/${script.itemId}`,
-        retry: "safe",
-        headers: { "X-Entity-Type": "http-request" },
-        body: [{ op: "add", path: "/scripts", value: toV3Scripts(script.exec) }]
-      });
+      try {
+        await this.gateway.requestJson({
+          service: "collection",
+          method: "patch",
+          path: `/v3/collections/${cid}/items/${script.itemId}`,
+          retry: "safe",
+          headers: { "X-Entity-Type": "http-request" },
+          body: [{ op: "add", path: "/scripts", value: toV3Scripts(script.exec) }]
+        });
+      } catch (error2) {
+        if (isRejectedPatchError(error2)) continue;
+        throw error2;
+      }
     }
     if (!items.some((i) => String(i.name ?? "") === "00 - Resolve Secrets")) {
       const created = await this.gateway.requestJson({
@@ -265018,36 +265353,47 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
   async createItemTree(cid, items, parentId) {
     for (const item of items) {
       const kind = String(item.$kind ?? "http-request");
-      let created;
-      try {
-        created = await this.gateway.requestJson({
-          service: "collection",
-          method: "post",
-          path: `/v3/collections/${cid}/items/`,
-          retry: "none",
-          headers: { "X-Entity-Type": kind },
-          body: this.buildItemCreateBody(item, parentId)
-        });
-      } catch (error2) {
-        if (!isAmbiguousTransportError(error2)) throw error2;
-        const name = String(item.name ?? "Untitled");
-        const matches = (await this.listCollectionItems(cid)).filter((candidate) => {
-          if (String(candidate.name ?? candidate.title ?? "") !== name) return false;
-          if (String(candidate.$kind ?? candidate.type ?? "http-request") !== kind) return false;
-          const position = asRecord8(candidate.position);
-          const parent = asRecord8(position?.parent);
-          const candidateParent = String(parent?.id ?? position?.parent ?? candidate.parent ?? "").trim();
-          return Boolean(candidateParent) && this.bareModelId(candidateParent) === this.bareModelId(parentId);
-        });
-        const match = adoptExactMatch(
-          `collection-item:${cid}:${parentId}:${kind}:${name}`,
-          matches,
-          (candidate) => String(candidate.id ?? "")
-        );
-        if (!match) throw error2;
-        created = { data: { id: match.id } };
+      const maxAttempts = 4;
+      let newId = "";
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        let created;
+        try {
+          created = await this.gateway.requestJson({
+            service: "collection",
+            method: "post",
+            path: `/v3/collections/${cid}/items/`,
+            retry: "none",
+            headers: { "X-Entity-Type": kind },
+            body: this.buildItemCreateBody(item, parentId)
+          });
+        } catch (error2) {
+          if (!isAmbiguousTransportError(error2)) throw error2;
+          const name = String(item.name ?? "Untitled");
+          const matches = (await this.listCollectionItems(cid)).filter((candidate) => {
+            if (String(candidate.name ?? candidate.title ?? "") !== name) return false;
+            if (String(candidate.$kind ?? candidate.type ?? "http-request") !== kind) return false;
+            const position = asRecord8(candidate.position);
+            const parent = asRecord8(position?.parent);
+            const candidateParent = String(parent?.id ?? position?.parent ?? candidate.parent ?? "").trim();
+            return Boolean(candidateParent) && this.bareModelId(candidateParent) === this.bareModelId(parentId);
+          });
+          const match = adoptExactMatch(
+            `collection-item:${cid}:${parentId}:${kind}:${name}`,
+            matches,
+            (candidate) => String(candidate.id ?? "")
+          );
+          if (match) {
+            created = { data: { id: match.id } };
+          } else {
+            const retriable = error2 instanceof HttpError && error2.status >= 500;
+            if (!retriable || attempt === maxAttempts) throw error2;
+            await this.sleep(fullJitterDelayMs(attempt - 1, 300, 2e3, this.random));
+            continue;
+          }
+        }
+        newId = String(asRecord8(created?.data)?.id ?? "").trim();
+        if (newId) break;
       }
-      const newId = String(asRecord8(created?.data)?.id ?? "").trim();
       if (!newId) {
         throw new Error(
           `Item create did not return an id for ${String(item.name ?? "item")}`
@@ -265090,6 +265436,30 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
    * - `remove` of /description always works (field exists as "")
    * - on update, GET the root first and only remove fields that currently exist
    */
+  /**
+   * GET a collection root, retrying through the v3 surface's read-after-write
+   * 404 lag. A freshly generated/renamed collection can transiently report
+   * RESOURCE_NOT_FOUND for a few seconds (worse under concurrent runner load);
+   * retrying absorbs that instead of hard-failing the run.
+   */
+  async getCollectionRoot(cid) {
+    const got = await retry(
+      () => this.gateway.requestJson({
+        service: "collection",
+        method: "get",
+        path: `/v3/collections/${cid}`,
+        retry: "none"
+      }),
+      {
+        maxAttempts: 6,
+        delayMs: 1e3,
+        backoffMultiplier: 2,
+        maxDelayMs: 8e3,
+        shouldRetry: (error2) => error2 instanceof HttpError && error2.status === 404
+      }
+    );
+    return asRecord8(got?.data);
+  }
   async applyCollectionLevelSettings(cid, v3, options = {}) {
     const ops = [];
     if (options.rename && typeof v3.name === "string" && v3.name) {
@@ -265097,12 +265467,7 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     }
     let current = null;
     if (options.reconcileRemovals) {
-      const got = await this.gateway.requestJson({
-        service: "collection",
-        method: "get",
-        path: `/v3/collections/${cid}`
-      });
-      current = asRecord8(got?.data);
+      current = await this.getCollectionRoot(cid);
     }
     const hasDescription = typeof v3.description === "string" && v3.description.length > 0;
     if (hasDescription) {
@@ -265141,6 +265506,9 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
       if (isMissingPatchValueError(error2) && ops.some((op) => op.op === "remove") && await this.verifyRootSettingsApplied(cid, ops)) {
         return;
       }
+      if (isRejectedPatchError(error2) && await this.verifyRootSettingsApplied(cid, ops)) {
+        return;
+      }
       throw error2;
     }
   }
@@ -265203,6 +265571,15 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
   async createCollection(workspaceId, collection, options = {}) {
     const v3 = this.normalizeCollectionForWrite(collection);
     const desiredName = String(v3.name ?? "Untitled Collection");
+    const existing = adoptExactMatch(
+      `collection:${workspaceId}:${desiredName}`,
+      await this.findCollectionsByExactName(workspaceId, desiredName),
+      (entry) => entry.id
+    );
+    if (existing) {
+      await this.updateCollection(existing.id, collection);
+      return existing.id;
+    }
     const submittedName = `${desiredName} [bootstrap:${this.createIdentity()}]`;
     const rootBody = { name: submittedName };
     let created;
@@ -265253,6 +265630,12 @@ var PostmanGatewayAssetsClient = class _PostmanGatewayAssetsClient {
     }
     return rawId;
   }
+  /** Patch only the durable collection description without reconciling its item tree. */
+  async updateCollectionDescription(collectionUid, description) {
+    const cid = this.bareModelId(collectionUid);
+    await this.getCollectionRoot(cid);
+    await this.applyCollectionLevelSettings(cid, { description });
+  }
   /**
    * Full-replace reconcile of a curated local v2.1.0 or collection v3 payload: delete every
    * root-level item (deleting a folder cascades its children server-side —
@@ -265334,6 +265717,7 @@ function detectInnerError(body2) {
   return typeof innerStatus === "number" && innerStatus >= 400 ? innerStatus : 502;
 }
 function isTransientGatewayError(status, body2) {
+  if (status === 429) return true;
   if (status === 502 || status === 503 || status === 504) return true;
   if (status >= 500 && (body2.includes("ESOCKETTIMEDOUT") || body2.includes("ETIMEDOUT") || body2.includes("ECONNRESET") || body2.includes("serverError") || body2.includes("downstream"))) {
     return true;
@@ -265352,8 +265736,10 @@ var AccessTokenGatewayClient = class {
   secretMasker;
   maxRetries;
   retryBaseDelayMs;
+  retryMaxDelayMs;
   requestTimeoutMs;
   sleepImpl;
+  randomImpl;
   constructor(options) {
     this.tokenProvider = options.tokenProvider;
     this.bifrostBaseUrl = String(
@@ -265365,8 +265751,10 @@ var AccessTokenGatewayClient = class {
     this.secretMasker = options.secretMasker ?? createSecretMasker([this.tokenProvider.current()]);
     this.maxRetries = options.maxRetries ?? 3;
     this.retryBaseDelayMs = options.retryBaseDelayMs ?? 400;
+    this.retryMaxDelayMs = options.retryMaxDelayMs ?? 5e3;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     this.sleepImpl = options.sleepImpl ?? defaultSleep;
+    this.randomImpl = options.randomImpl ?? Math.random;
   }
   configureTeamContext(teamId, orgMode) {
     this.teamId = String(teamId || "").trim();
@@ -265426,7 +265814,7 @@ var AccessTokenGatewayClient = class {
         response = await this.send(request);
       } catch (error2) {
         if (retryMode === "safe" && attempt < this.maxRetries) {
-          const delay = this.retryBaseDelayMs * 2 ** attempt;
+          const delay = this.retryDelayMs(attempt);
           attempt += 1;
           await this.sleepImpl(delay);
           continue;
@@ -265438,7 +265826,7 @@ var AccessTokenGatewayClient = class {
         const innerStatus = detectInnerError(okBody);
         if (innerStatus !== null) {
           if (retryMode === "safe" && isTransientGatewayError(innerStatus, okBody) && attempt < this.maxRetries) {
-            const delay = this.retryBaseDelayMs * 2 ** attempt;
+            const delay = this.retryDelayMs(attempt);
             attempt += 1;
             await this.sleepImpl(delay);
             continue;
@@ -265463,7 +265851,10 @@ var AccessTokenGatewayClient = class {
         throw this.toHttpError(request, response, retryBody);
       }
       if (retryMode === "safe" && isTransientGatewayError(response.status, body2) && attempt < this.maxRetries) {
-        const delay = this.retryBaseDelayMs * 2 ** attempt;
+        const delay = this.retryDelayMs(
+          attempt,
+          parseRetryAfterMs2(response.headers.get("retry-after"))
+        );
         attempt += 1;
         await this.sleepImpl(delay);
         continue;
@@ -265471,13 +265862,26 @@ var AccessTokenGatewayClient = class {
       throw this.toHttpError(request, response, body2);
     }
   }
+  /**
+   * Full-jitter backoff (uniform in [0, min(cap, base * 2^attempt))) so
+   * concurrent CI runners that fail together never retry in lockstep against
+   * the shared gateway. A server-sent Retry-After beats the heuristic: it is
+   * authoritative backpressure, honored verbatim (capped by the ceiling).
+   */
+  retryDelayMs(attempt, retryAfterMs) {
+    if (retryAfterMs !== void 0) {
+      return Math.min(this.retryMaxDelayMs, retryAfterMs);
+    }
+    return fullJitterDelayMs(attempt, this.retryBaseDelayMs, this.retryMaxDelayMs, this.randomImpl);
+  }
   /**
    * The success path reads the body to inspect for an inner error, which
    * consumes the stream. Hand callers a fresh Response over the buffered text so
    * `requestJson` can still parse it.
    */
   rebuildResponse(response, body2) {
-    return new Response(body2, {
+    const nullBody = response.status === 204 || response.status === 205 || response.status === 304;
+    return new Response(nullBody ? null : body2, {
       status: response.status,
       statusText: response.statusText,
       headers: response.headers
@@ -266207,6 +266611,9 @@ function createTelemetryContext(options) {
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
 function resolveActionVersion2() {
+  if (false) {
+    return void 0;
+  }
   try {
     const raw = (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(__dirname, "..", "package.json"), "utf8");
     return JSON.parse(raw).version ?? "unknown";
@@ -281929,6 +282336,61 @@ function serializeOpenApiDocument(document2) {
   return `${JSON.stringify(document2, null, 2)}
 `;
 }
+function typeNullPath(pathSegments) {
+  return pathSegments.map(String).join(".");
+}
+function isNullOnlySchema(value) {
+  const record = asRecord10(value);
+  if (!record || record.type !== "null") return false;
+  return Object.keys(record).every((key) => key === "type" || key.startsWith("x-"));
+}
+function createOas30TypeNullCompatibilityDocument(sourceDocument) {
+  const document2 = structuredClone(sourceDocument);
+  const sourceTypeNullPaths = [];
+  const visit4 = (value, pathSegments) => {
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => visit4(entry, [...pathSegments, index]));
+      return;
+    }
+    const record = asRecord10(value);
+    if (!record) return;
+    const oneOf = Array.isArray(record.oneOf) ? record.oneOf : void 0;
+    const nullIndexes = oneOf ? oneOf.flatMap((entry, index) => isNullOnlySchema(entry) ? [index] : []) : [];
+    if (nullIndexes.length > 0) {
+      if (oneOf?.length !== 2 || nullIndexes.length !== 1) {
+        throw new Error(
+          `CONTRACT_OAS30_TYPE_NULL_UNSUPPORTED: ${typeNullPath(pathSegments)} must use oneOf with exactly one null-only member and one non-null schema`
+        );
+      }
+      const nullIndex = nullIndexes[0];
+      const nonNullIndex = nullIndex === 0 ? 1 : 0;
+      const nonNullSchema = asRecord10(oneOf[nonNullIndex]);
+      if (!nonNullSchema || nonNullSchema.type === "null") {
+        throw new Error(
+          `CONTRACT_OAS30_TYPE_NULL_UNSUPPORTED: ${typeNullPath(pathSegments)} must pair the null-only member with one non-null schema`
+        );
+      }
+      const siblings = Object.fromEntries(
+        Object.entries(record).filter(([key]) => key !== "oneOf")
+      );
+      for (const key of Object.keys(record)) delete record[key];
+      Object.assign(record, structuredClone(nonNullSchema), siblings, { nullable: true });
+      sourceTypeNullPaths.push(typeNullPath([...pathSegments, "oneOf", nullIndex, "type"]));
+      visit4(record, pathSegments);
+      return;
+    }
+    if (record.type === "null") {
+      throw new Error(
+        `CONTRACT_OAS30_TYPE_NULL_UNSUPPORTED: ${typeNullPath([...pathSegments, "type"])} is not a supported nullable oneOf member`
+      );
+    }
+    for (const [key, child4] of Object.entries(record)) {
+      visit4(child4, [...pathSegments, key]);
+    }
+  };
+  visit4(document2, []);
+  return { document: document2, sourceTypeNullPaths };
+}
 async function bundleSpec(baseUrl, document2, options) {
   const budget = options.budget ?? { refs: 0, totalBytes: Buffer.byteLength(JSON.stringify(document2), "utf8") };
   const fetchText = options.fetchText ?? safeFetchText;
@@ -281970,7 +282432,14 @@ function createCachedFetchText(options) {
 async function buildLoadedSpec(content, baseRef, options, fetchText, budget) {
   const document2 = parseOpenApiDocument(content);
   const version = detectOpenApiVersion2(document2);
-  const bundledDocument = await bundleSpec(baseRef, document2, { ...options, budget, fetchText });
+  let contractDocument = document2;
+  let sourceTypeNullPaths = [];
+  if (options.preserveOas30TypeNull && version === "3.0") {
+    const compatibility = createOas30TypeNullCompatibilityDocument(document2);
+    contractDocument = compatibility.document;
+    sourceTypeNullPaths = compatibility.sourceTypeNullPaths;
+  }
+  const bundledDocument = await bundleSpec(baseRef, contractDocument, { ...options, budget, fetchText });
   const validation = await validate(bundledDocument, {
     resolve: { external: false, file: false },
     dereference: { circular: "ignore" },
@@ -281984,6 +282453,7 @@ async function buildLoadedSpec(content, baseRef, options, fetchText, budget) {
     bundledDocument,
     contractIndex: buildContractIndex(bundledDocument),
     content,
+    sourceTypeNullPaths,
     version
   };
 }
@@ -282109,6 +282579,309 @@ function looksLikeIntrospection(record) {
   return Boolean(data && typeof data === "object" && data.__schema);
 }
 
+// src/lib/repo/branch-decision.ts
+var import_node_fs5 = require("node:fs");
+var import_node_crypto4 = require("node:crypto");
+var ContractError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.code = code;
+    this.name = "ContractError";
+  }
+};
+function clean(value) {
+  const trimmed = (value ?? "").trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function stripRefPrefix(ref) {
+  const raw = clean(ref);
+  if (!raw) {
+    return { kind: "unknown" };
+  }
+  if (raw.startsWith("refs/heads/")) {
+    return { name: raw.slice("refs/heads/".length), kind: "branch" };
+  }
+  if (raw.startsWith("refs/tags/")) {
+    return { name: raw.slice("refs/tags/".length), kind: "tag" };
+  }
+  if (raw.startsWith("refs/pull/") || raw.startsWith("refs/merge")) {
+    return { kind: "unknown" };
+  }
+  return { name: raw, kind: "branch" };
+}
+function detectProvider(env) {
+  if (clean(env.GITHUB_ACTIONS) || clean(env.GITHUB_REPOSITORY)) return "github";
+  if (clean(env.GITLAB_CI) || clean(env.CI_PROJECT_PATH)) return "gitlab";
+  if (clean(env.BITBUCKET_REPO_SLUG) || clean(env.BITBUCKET_BRANCH)) return "bitbucket";
+  if (clean(env.TF_BUILD) || clean(env.BUILD_REPOSITORY_URI)) return "azure-devops";
+  return "unknown";
+}
+function readGithubEvent(env) {
+  const path10 = clean(env.GITHUB_EVENT_PATH);
+  if (!path10) return void 0;
+  try {
+    return JSON.parse((0, import_node_fs5.readFileSync)(path10, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function resolveBranchIdentity(env = process.env, overrides = {}) {
+  const provider = detectProvider(env);
+  const explicitDefault = clean(overrides.defaultBranch);
+  let headBranch;
+  let rawRef;
+  let refKind;
+  let isPrContext = false;
+  let isForkPr = false;
+  let defaultBranch = explicitDefault;
+  let headSha;
+  switch (provider) {
+    case "github": {
+      const event2 = readGithubEvent(env);
+      headSha = clean(env.GITHUB_SHA);
+      defaultBranch ??= clean(event2?.repository?.default_branch);
+      const headRef = clean(env.GITHUB_HEAD_REF);
+      if (headRef) {
+        isPrContext = true;
+        headBranch = headRef;
+        rawRef = clean(env.GITHUB_REF) ?? headRef;
+        refKind = "branch";
+        const headRepo = event2?.pull_request?.head?.repo?.full_name;
+        const baseRepo = event2?.pull_request?.base?.repo?.full_name ?? event2?.repository?.full_name;
+        isForkPr = Boolean(headRepo && baseRepo && headRepo !== baseRepo);
+        headSha = clean(event2?.pull_request?.head?.sha) ?? headSha;
+      } else {
+        rawRef = clean(env.GITHUB_REF) ?? clean(env.GITHUB_REF_NAME);
+        const parsed = stripRefPrefix(rawRef);
+        headBranch = parsed.kind === "branch" ? parsed.name : void 0;
+        refKind = parsed.kind;
+      }
+      break;
+    }
+    case "gitlab": {
+      headSha = clean(env.CI_COMMIT_SHA);
+      defaultBranch ??= clean(env.CI_DEFAULT_BRANCH);
+      const mrSource = clean(env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME);
+      if (mrSource) {
+        isPrContext = true;
+        headBranch = mrSource;
+        rawRef = mrSource;
+        refKind = "branch";
+        const sourceProject = clean(env.CI_MERGE_REQUEST_SOURCE_PROJECT_ID);
+        const targetProject = clean(env.CI_MERGE_REQUEST_PROJECT_ID);
+        isForkPr = Boolean(sourceProject && targetProject && sourceProject !== targetProject);
+      } else if (clean(env.CI_COMMIT_TAG)) {
+        rawRef = clean(env.CI_COMMIT_TAG);
+        refKind = "tag";
+      } else {
+        headBranch = clean(env.CI_COMMIT_BRANCH) ?? clean(env.CI_COMMIT_REF_NAME);
+        rawRef = headBranch;
+        refKind = headBranch ? "branch" : "unknown";
+      }
+      break;
+    }
+    case "bitbucket": {
+      headSha = clean(env.BITBUCKET_COMMIT);
+      if (clean(env.BITBUCKET_TAG)) {
+        rawRef = clean(env.BITBUCKET_TAG);
+        refKind = "tag";
+      } else {
+        headBranch = clean(env.BITBUCKET_BRANCH);
+        rawRef = headBranch;
+        refKind = headBranch ? "branch" : "unknown";
+        isPrContext = Boolean(clean(env.BITBUCKET_PR_ID));
+      }
+      break;
+    }
+    case "azure-devops": {
+      headSha = clean(env.BUILD_SOURCEVERSION);
+      const prSource = clean(env.SYSTEM_PULLREQUEST_SOURCEBRANCH);
+      if (prSource) {
+        isPrContext = true;
+        const parsed = stripRefPrefix(prSource);
+        headBranch = parsed.kind === "branch" ? parsed.name : void 0;
+        rawRef = prSource;
+        refKind = parsed.kind;
+        const forkFlag = clean(env.SYSTEM_PULLREQUEST_ISFORK);
+        isForkPr = forkFlag?.toLowerCase() === "true";
+      } else {
+        rawRef = clean(env.BUILD_SOURCEBRANCH);
+        const parsed = stripRefPrefix(rawRef);
+        headBranch = parsed.kind === "branch" ? parsed.name : void 0;
+        refKind = parsed.kind;
+      }
+      break;
+    }
+    default: {
+      refKind = "unknown";
+    }
+  }
+  if (refKind === "branch" && headBranch && defaultBranch && headBranch === defaultBranch) {
+    refKind = "default-branch";
+  }
+  return { provider, headBranch, rawRef, defaultBranch, refKind, isPrContext, isForkPr, headSha };
+}
+function parseChannelRules(input) {
+  const raw = clean(input);
+  const rules = [];
+  for (const part of raw ? raw.split(",") : []) {
+    const entry = part.trim();
+    if (!entry) continue;
+    const eq = entry.indexOf("=");
+    if (eq <= 0 || eq === entry.length - 1) {
+      throw new ContractError(
+        "CONTRACT_CHANNELS_INPUT_INVALID",
+        `channels entry "${entry}" must be <branch-or-glob>=<CODE>`
+      );
+    }
+    const pattern = entry.slice(0, eq).trim();
+    const code = entry.slice(eq + 1).trim().toUpperCase();
+    if (!/^[A-Z][A-Z0-9_-]{0,15}$/.test(code)) {
+      throw new ContractError(
+        "CONTRACT_CHANNELS_INPUT_INVALID",
+        `channel code "${code}" must be 1-16 chars, A-Z 0-9 _ -, starting with a letter`
+      );
+    }
+    rules.push({ pattern, code });
+  }
+  if (!rules.some((rule) => rule.pattern === "release/*")) {
+    rules.push({ pattern: "release/*", code: "RC" });
+  }
+  return rules;
+}
+function matchChannel(branch, rules) {
+  for (const rule of rules) {
+    if (rule.pattern.endsWith("*")) {
+      const prefix = rule.pattern.slice(0, -1);
+      if (branch.startsWith(prefix)) return rule;
+    } else if (branch === rule.pattern) {
+      return rule;
+    }
+  }
+  return void 0;
+}
+function resolveBranchDecision(options) {
+  const { strategy, identity } = options;
+  const channels = options.channels ?? [];
+  if (strategy === "legacy") {
+    return {
+      tier: "legacy",
+      strategy,
+      identity,
+      canonicalBranch: clean(options.canonicalBranch) ?? identity.defaultBranch,
+      reason: "branch-strategy legacy: branch-blind pre-v2 behavior"
+    };
+  }
+  const canonicalBranch = clean(options.canonicalBranch) ?? identity.defaultBranch;
+  if (!canonicalBranch) {
+    throw new ContractError(
+      "CONTRACT_DEFAULT_BRANCH_UNRESOLVED",
+      `cannot resolve the canonical branch on ${identity.provider} (no explicit canonical-branch input and the provider exposes no default-branch variable). Set the canonical-branch input.`
+    );
+  }
+  if (identity.refKind === "tag" || identity.refKind === "unknown" || !identity.headBranch) {
+    return {
+      tier: "gated",
+      strategy,
+      identity,
+      canonicalBranch,
+      reason: `ref kind ${identity.refKind}: never canonical/preview-eligible; no-op with annotation`
+    };
+  }
+  if (identity.headBranch === canonicalBranch) {
+    return {
+      tier: "canonical",
+      strategy,
+      identity,
+      canonicalBranch,
+      reason: `head branch equals canonical branch ${canonicalBranch}`
+    };
+  }
+  const channel = matchChannel(identity.headBranch, channels);
+  if (channel) {
+    return {
+      tier: "channel",
+      strategy,
+      identity,
+      canonicalBranch,
+      channel,
+      reason: `branch ${identity.headBranch} matches channel ${channel.pattern}=${channel.code}`
+    };
+  }
+  if (strategy === "preview") {
+    if (identity.isForkPr) {
+      return {
+        tier: "gated",
+        strategy,
+        identity,
+        canonicalBranch,
+        reason: "fork PR: preview-ineligible (same-repo gate), gated instead"
+      };
+    }
+    return {
+      tier: "preview",
+      strategy,
+      identity,
+      canonicalBranch,
+      reason: `branch ${identity.headBranch} under branch-strategy preview`
+    };
+  }
+  return {
+    tier: "gated",
+    strategy,
+    identity,
+    canonicalBranch,
+    reason: `branch ${identity.headBranch} under branch-strategy publish-gate`
+  };
+}
+var BRANCH_DECISION_ENV = "POSTMAN_BRANCH_DECISION";
+function serializeBranchDecision(decision) {
+  return JSON.stringify(decision);
+}
+function parseBranchDecision(raw) {
+  const value = clean(raw);
+  if (!value) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new ContractError("CONTRACT_BRANCH_DECISION_INVALID", "POSTMAN_BRANCH_DECISION is not valid JSON");
+  }
+  const candidate = parsed;
+  const tiers = ["canonical", "channel", "preview", "gated", "legacy"];
+  if (!candidate || typeof candidate !== "object" || !tiers.includes(candidate.tier) || !candidate.identity) {
+    throw new ContractError("CONTRACT_BRANCH_DECISION_INVALID", "POSTMAN_BRANCH_DECISION does not carry a valid BranchDecision");
+  }
+  return candidate;
+}
+function resolveEffectiveBranchDecision(options, env = process.env) {
+  const inherited = parseBranchDecision(env[BRANCH_DECISION_ENV]);
+  if (inherited) return inherited;
+  return resolveBranchDecision(options);
+}
+var PREVIEW_SLUG_MAX = 30;
+function buildBranchSlug(rawBranch) {
+  const sanitized = rawBranch.replace(/^refs\/heads\//, "").replace(/\s+/g, "-").replace(/[^A-Za-z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^[._-]+|[._-]+$/g, "");
+  const truncated = sanitized.slice(0, PREVIEW_SLUG_MAX);
+  const lossy = truncated !== rawBranch.replace(/^refs\/heads\//, "");
+  if (!lossy) {
+    return { suffix: truncated, slug: truncated, lossy };
+  }
+  const hash = (0, import_node_crypto4.createHash)("sha256").update(rawBranch).digest("hex").slice(0, 6);
+  return { suffix: `${truncated}-${hash}`, slug: truncated, lossy };
+}
+function previewAssetName(baseName, rawBranch) {
+  return `${baseName} @${buildBranchSlug(rawBranch).suffix}`;
+}
+function channelAssetName(baseName, code) {
+  return `[${code}] ${baseName}`;
+}
+var MARKER_KEY = "x-pm-onboarding";
+function renderAssetMarker(marker) {
+  return `${MARKER_KEY}: ${JSON.stringify(marker)}`;
+}
+
 // node_modules/graphql/jsutils/inspect.mjs
 var MAX_ARRAY_LENGTH = 10;
 var MAX_RECURSIVE_DEPTH = 2;
@@ -298640,940 +299413,6 @@ function getPositionFromMatch(match) {
 }
 
 // node_modules/@nodable/entities/src/entities.js
-var BASIC_LATIN = {
-  amp: "&",
-  AMP: "&",
-  lt: "<",
-  LT: "<",
-  gt: ">",
-  GT: ">",
-  quot: '"',
-  QUOT: '"',
-  apos: "'",
-  lsquo: "\u2018",
-  rsquo: "\u2019",
-  ldquo: "\u201C",
-  rdquo: "\u201D",
-  lsquor: "\u201A",
-  rsquor: "\u2019",
-  ldquor: "\u201E",
-  bdquo: "\u201E",
-  comma: ",",
-  period: ".",
-  colon: ":",
-  semi: ";",
-  excl: "!",
-  quest: "?",
-  num: "#",
-  dollar: "$",
-  percent: "%",
-  ast: "*",
-  commat: "@",
-  lowbar: "_",
-  verbar: "|",
-  vert: "|",
-  sol: "/",
-  bsol: "\\",
-  lbrace: "{",
-  rbrace: "}",
-  lbrack: "[",
-  rbrack: "]",
-  lpar: "(",
-  rpar: ")",
-  nbsp: "\xA0",
-  iexcl: "\xA1",
-  cent: "\xA2",
-  pound: "\xA3",
-  curren: "\xA4",
-  yen: "\xA5",
-  brvbar: "\xA6",
-  sect: "\xA7",
-  uml: "\xA8",
-  copy: "\xA9",
-  COPY: "\xA9",
-  ordf: "\xAA",
-  laquo: "\xAB",
-  not: "\xAC",
-  shy: "\xAD",
-  reg: "\xAE",
-  REG: "\xAE",
-  macr: "\xAF",
-  deg: "\xB0",
-  plusmn: "\xB1",
-  sup2: "\xB2",
-  sup3: "\xB3",
-  acute: "\xB4",
-  micro: "\xB5",
-  para: "\xB6",
-  middot: "\xB7",
-  cedil: "\xB8",
-  sup1: "\xB9",
-  ordm: "\xBA",
-  raquo: "\xBB",
-  frac14: "\xBC",
-  frac12: "\xBD",
-  half: "\xBD",
-  frac34: "\xBE",
-  iquest: "\xBF",
-  times: "\xD7",
-  div: "\xF7",
-  divide: "\xF7"
-};
-var LATIN_ACCENTS = {
-  Agrave: "\xC0",
-  agrave: "\xE0",
-  Aacute: "\xC1",
-  aacute: "\xE1",
-  Acirc: "\xC2",
-  acirc: "\xE2",
-  Atilde: "\xC3",
-  atilde: "\xE3",
-  Auml: "\xC4",
-  auml: "\xE4",
-  Aring: "\xC5",
-  aring: "\xE5",
-  AElig: "\xC6",
-  aelig: "\xE6",
-  Ccedil: "\xC7",
-  ccedil: "\xE7",
-  Egrave: "\xC8",
-  egrave: "\xE8",
-  Eacute: "\xC9",
-  eacute: "\xE9",
-  Ecirc: "\xCA",
-  ecirc: "\xEA",
-  Euml: "\xCB",
-  euml: "\xEB",
-  Igrave: "\xCC",
-  igrave: "\xEC",
-  Iacute: "\xCD",
-  iacute: "\xED",
-  Icirc: "\xCE",
-  icirc: "\xEE",
-  Iuml: "\xCF",
-  iuml: "\xEF",
-  ETH: "\xD0",
-  eth: "\xF0",
-  Ntilde: "\xD1",
-  ntilde: "\xF1",
-  Ograve: "\xD2",
-  ograve: "\xF2",
-  Oacute: "\xD3",
-  oacute: "\xF3",
-  Ocirc: "\xD4",
-  ocirc: "\xF4",
-  Otilde: "\xD5",
-  otilde: "\xF5",
-  Ouml: "\xD6",
-  ouml: "\xF6",
-  Oslash: "\xD8",
-  oslash: "\xF8",
-  Ugrave: "\xD9",
-  ugrave: "\xF9",
-  Uacute: "\xDA",
-  uacute: "\xFA",
-  Ucirc: "\xDB",
-  ucirc: "\xFB",
-  Uuml: "\xDC",
-  uuml: "\xFC",
-  Yacute: "\xDD",
-  yacute: "\xFD",
-  THORN: "\xDE",
-  thorn: "\xFE",
-  szlig: "\xDF",
-  yuml: "\xFF",
-  Yuml: "\u0178"
-};
-var LATIN_EXTENDED = {
-  Amacr: "\u0100",
-  amacr: "\u0101",
-  Abreve: "\u0102",
-  abreve: "\u0103",
-  Aogon: "\u0104",
-  aogon: "\u0105",
-  Cacute: "\u0106",
-  cacute: "\u0107",
-  Ccirc: "\u0108",
-  ccirc: "\u0109",
-  Cdot: "\u010A",
-  cdot: "\u010B",
-  Ccaron: "\u010C",
-  ccaron: "\u010D",
-  Dcaron: "\u010E",
-  dcaron: "\u010F",
-  Dstrok: "\u0110",
-  dstrok: "\u0111",
-  Emacr: "\u0112",
-  emacr: "\u0113",
-  Ecaron: "\u011A",
-  ecaron: "\u011B",
-  Edot: "\u0116",
-  edot: "\u0117",
-  Eogon: "\u0118",
-  eogon: "\u0119",
-  Gcirc: "\u011C",
-  gcirc: "\u011D",
-  Gbreve: "\u011E",
-  gbreve: "\u011F",
-  Gdot: "\u0120",
-  gdot: "\u0121",
-  Gcedil: "\u0122",
-  Hcirc: "\u0124",
-  hcirc: "\u0125",
-  Hstrok: "\u0126",
-  hstrok: "\u0127",
-  Itilde: "\u0128",
-  itilde: "\u0129",
-  Imacr: "\u012A",
-  imacr: "\u012B",
-  Iogon: "\u012E",
-  iogon: "\u012F",
-  Idot: "\u0130",
-  IJlig: "\u0132",
-  ijlig: "\u0133",
-  Jcirc: "\u0134",
-  jcirc: "\u0135",
-  Kcedil: "\u0136",
-  kcedil: "\u0137",
-  kgreen: "\u0138",
-  Lacute: "\u0139",
-  lacute: "\u013A",
-  Lcedil: "\u013B",
-  lcedil: "\u013C",
-  Lcaron: "\u013D",
-  lcaron: "\u013E",
-  Lmidot: "\u013F",
-  lmidot: "\u0140",
-  Lstrok: "\u0141",
-  lstrok: "\u0142",
-  Nacute: "\u0143",
-  nacute: "\u0144",
-  Ncaron: "\u0147",
-  ncaron: "\u0148",
-  Ncedil: "\u0145",
-  ncedil: "\u0146",
-  ENG: "\u014A",
-  eng: "\u014B",
-  Omacr: "\u014C",
-  omacr: "\u014D",
-  Odblac: "\u0150",
-  odblac: "\u0151",
-  OElig: "\u0152",
-  oelig: "\u0153",
-  Racute: "\u0154",
-  racute: "\u0155",
-  Rcaron: "\u0158",
-  rcaron: "\u0159",
-  Rcedil: "\u0156",
-  rcedil: "\u0157",
-  Sacute: "\u015A",
-  sacute: "\u015B",
-  Scirc: "\u015C",
-  scirc: "\u015D",
-  Scedil: "\u015E",
-  scedil: "\u015F",
-  Scaron: "\u0160",
-  scaron: "\u0161",
-  Tcedil: "\u0162",
-  tcedil: "\u0163",
-  Tcaron: "\u0164",
-  tcaron: "\u0165",
-  Tstrok: "\u0166",
-  tstrok: "\u0167",
-  Utilde: "\u0168",
-  utilde: "\u0169",
-  Umacr: "\u016A",
-  umacr: "\u016B",
-  Ubreve: "\u016C",
-  ubreve: "\u016D",
-  Uring: "\u016E",
-  uring: "\u016F",
-  Udblac: "\u0170",
-  udblac: "\u0171",
-  Uogon: "\u0172",
-  uogon: "\u0173",
-  Wcirc: "\u0174",
-  wcirc: "\u0175",
-  Ycirc: "\u0176",
-  ycirc: "\u0177",
-  Zacute: "\u0179",
-  zacute: "\u017A",
-  Zdot: "\u017B",
-  zdot: "\u017C",
-  Zcaron: "\u017D",
-  zcaron: "\u017E"
-};
-var GREEK = {
-  Alpha: "\u0391",
-  alpha: "\u03B1",
-  Beta: "\u0392",
-  beta: "\u03B2",
-  Gamma: "\u0393",
-  gamma: "\u03B3",
-  Delta: "\u0394",
-  delta: "\u03B4",
-  Epsilon: "\u0395",
-  epsilon: "\u03B5",
-  epsiv: "\u03F5",
-  varepsilon: "\u03F5",
-  Zeta: "\u0396",
-  zeta: "\u03B6",
-  Eta: "\u0397",
-  eta: "\u03B7",
-  Theta: "\u0398",
-  theta: "\u03B8",
-  thetasym: "\u03D1",
-  vartheta: "\u03D1",
-  Iota: "\u0399",
-  iota: "\u03B9",
-  Kappa: "\u039A",
-  kappa: "\u03BA",
-  kappav: "\u03F0",
-  varkappa: "\u03F0",
-  Lambda: "\u039B",
-  lambda: "\u03BB",
-  Mu: "\u039C",
-  mu: "\u03BC",
-  Nu: "\u039D",
-  nu: "\u03BD",
-  Xi: "\u039E",
-  xi: "\u03BE",
-  Omicron: "\u039F",
-  omicron: "\u03BF",
-  Pi: "\u03A0",
-  pi: "\u03C0",
-  piv: "\u03D6",
-  varpi: "\u03D6",
-  Rho: "\u03A1",
-  rho: "\u03C1",
-  rhov: "\u03F1",
-  varrho: "\u03F1",
-  Sigma: "\u03A3",
-  sigma: "\u03C3",
-  sigmaf: "\u03C2",
-  sigmav: "\u03C2",
-  varsigma: "\u03C2",
-  Tau: "\u03A4",
-  tau: "\u03C4",
-  Upsilon: "\u03A5",
-  upsilon: "\u03C5",
-  upsi: "\u03C5",
-  Upsi: "\u03D2",
-  upsih: "\u03D2",
-  Phi: "\u03A6",
-  phi: "\u03C6",
-  phiv: "\u03D5",
-  varphi: "\u03D5",
-  Chi: "\u03A7",
-  chi: "\u03C7",
-  Psi: "\u03A8",
-  psi: "\u03C8",
-  Omega: "\u03A9",
-  omega: "\u03C9",
-  ohm: "\u03A9",
-  Gammad: "\u03DC",
-  gammad: "\u03DD",
-  digamma: "\u03DD"
-};
-var CYRILLIC = {
-  Afr: "\u{1D504}",
-  afr: "\u{1D51E}",
-  Acy: "\u0410",
-  acy: "\u0430",
-  Bcy: "\u0411",
-  bcy: "\u0431",
-  Vcy: "\u0412",
-  vcy: "\u0432",
-  Gcy: "\u0413",
-  gcy: "\u0433",
-  Dcy: "\u0414",
-  dcy: "\u0434",
-  IEcy: "\u0415",
-  iecy: "\u0435",
-  IOcy: "\u0401",
-  iocy: "\u0451",
-  ZHcy: "\u0416",
-  zhcy: "\u0436",
-  Zcy: "\u0417",
-  zcy: "\u0437",
-  Icy: "\u0418",
-  icy: "\u0438",
-  Jcy: "\u0419",
-  jcy: "\u0439",
-  Kcy: "\u041A",
-  kcy: "\u043A",
-  Lcy: "\u041B",
-  lcy: "\u043B",
-  Mcy: "\u041C",
-  mcy: "\u043C",
-  Ncy: "\u041D",
-  ncy: "\u043D",
-  Ocy: "\u041E",
-  ocy: "\u043E",
-  Pcy: "\u041F",
-  pcy: "\u043F",
-  Rcy: "\u0420",
-  rcy: "\u0440",
-  Scy: "\u0421",
-  scy: "\u0441",
-  Tcy: "\u0422",
-  tcy: "\u0442",
-  Ucy: "\u0423",
-  ucy: "\u0443",
-  Fcy: "\u0424",
-  fcy: "\u0444",
-  KHcy: "\u0425",
-  khcy: "\u0445",
-  TScy: "\u0426",
-  tscy: "\u0446",
-  CHcy: "\u0427",
-  chcy: "\u0447",
-  SHcy: "\u0428",
-  shcy: "\u0448",
-  SHCHcy: "\u0429",
-  shchcy: "\u0449",
-  HARDcy: "\u042A",
-  hardcy: "\u044A",
-  Ycy: "\u042B",
-  ycy: "\u044B",
-  SOFTcy: "\u042C",
-  softcy: "\u044C",
-  Ecy: "\u042D",
-  ecy: "\u044D",
-  YUcy: "\u042E",
-  yucy: "\u044E",
-  YAcy: "\u042F",
-  yacy: "\u044F",
-  DJcy: "\u0402",
-  djcy: "\u0452",
-  GJcy: "\u0403",
-  gjcy: "\u0453",
-  Jukcy: "\u0404",
-  jukcy: "\u0454",
-  DScy: "\u0405",
-  dscy: "\u0455",
-  Iukcy: "\u0406",
-  iukcy: "\u0456",
-  YIcy: "\u0407",
-  yicy: "\u0457",
-  Jsercy: "\u0408",
-  jsercy: "\u0458",
-  LJcy: "\u0409",
-  ljcy: "\u0459",
-  NJcy: "\u040A",
-  njcy: "\u045A",
-  TSHcy: "\u040B",
-  tshcy: "\u045B",
-  KJcy: "\u040C",
-  kjcy: "\u045C",
-  Ubrcy: "\u040E",
-  ubrcy: "\u045E",
-  DZcy: "\u040F",
-  dzcy: "\u045F"
-};
-var MATH = {
-  plus: "+",
-  pm: "\xB1",
-  times: "\xD7",
-  div: "\xF7",
-  divide: "\xF7",
-  sdot: "\u22C5",
-  star: "\u2606",
-  starf: "\u2605",
-  bigstar: "\u2605",
-  lowast: "\u2217",
-  ast: "*",
-  midast: "*",
-  compfn: "\u2218",
-  smallcircle: "\u2218",
-  bullet: "\u2022",
-  bull: "\u2022",
-  nbsp: "\xA0",
-  hellip: "\u2026",
-  mldr: "\u2026",
-  prime: "\u2032",
-  Prime: "\u2033",
-  tprime: "\u2034",
-  bprime: "\u2035",
-  backprime: "\u2035",
-  minus: "\u2212",
-  minusd: "\u2238",
-  dotminus: "\u2238",
-  plusdo: "\u2214",
-  dotplus: "\u2214",
-  plusmn: "\xB1",
-  minusplus: "\u2213",
-  mnplus: "\u2213",
-  mp: "\u2213",
-  setminus: "\u2216",
-  smallsetminus: "\u2216",
-  Backslash: "\u2216",
-  setmn: "\u2216",
-  ssetmn: "\u2216",
-  lowbar: "_",
-  verbar: "|",
-  vert: "|",
-  VerticalLine: "|",
-  colon: ":",
-  Colon: "\u2237",
-  Proportion: "\u2237",
-  ratio: "\u2236",
-  equals: "=",
-  ne: "\u2260",
-  nequiv: "\u2262",
-  equiv: "\u2261",
-  Congruent: "\u2261",
-  sim: "\u223C",
-  thicksim: "\u223C",
-  thksim: "\u223C",
-  sime: "\u2243",
-  simeq: "\u2243",
-  TildeEqual: "\u2243",
-  asymp: "\u2248",
-  approx: "\u2248",
-  thickapprox: "\u2248",
-  thkap: "\u2248",
-  TildeTilde: "\u2248",
-  ncong: "\u2247",
-  cong: "\u2245",
-  TildeFullEqual: "\u2245",
-  asympeq: "\u224D",
-  CupCap: "\u224D",
-  bump: "\u224E",
-  Bumpeq: "\u224E",
-  HumpDownHump: "\u224E",
-  bumpe: "\u224F",
-  bumpeq: "\u224F",
-  HumpEqual: "\u224F",
-  le: "\u2264",
-  LessEqual: "\u2264",
-  ge: "\u2265",
-  GreaterEqual: "\u2265",
-  lesseqgtr: "\u22DA",
-  lesseqqgtr: "\u2A8B",
-  greater: ">",
-  less: "<"
-};
-var MATH_ADVANCED = {
-  alefsym: "\u2135",
-  aleph: "\u2135",
-  beth: "\u2136",
-  gimel: "\u2137",
-  daleth: "\u2138",
-  forall: "\u2200",
-  ForAll: "\u2200",
-  part: "\u2202",
-  PartialD: "\u2202",
-  exist: "\u2203",
-  Exists: "\u2203",
-  nexist: "\u2204",
-  nexists: "\u2204",
-  empty: "\u2205",
-  emptyset: "\u2205",
-  emptyv: "\u2205",
-  varnothing: "\u2205",
-  nabla: "\u2207",
-  Del: "\u2207",
-  isin: "\u2208",
-  isinv: "\u2208",
-  in: "\u2208",
-  Element: "\u2208",
-  notin: "\u2209",
-  notinva: "\u2209",
-  ni: "\u220B",
-  niv: "\u220B",
-  SuchThat: "\u220B",
-  ReverseElement: "\u220B",
-  notni: "\u220C",
-  notniva: "\u220C",
-  prod: "\u220F",
-  Product: "\u220F",
-  coprod: "\u2210",
-  Coproduct: "\u2210",
-  sum: "\u2211",
-  Sum: "\u2211",
-  minus: "\u2212",
-  mp: "\u2213",
-  plusdo: "\u2214",
-  dotplus: "\u2214",
-  setminus: "\u2216",
-  lowast: "\u2217",
-  radic: "\u221A",
-  Sqrt: "\u221A",
-  prop: "\u221D",
-  propto: "\u221D",
-  Proportional: "\u221D",
-  varpropto: "\u221D",
-  infin: "\u221E",
-  infintie: "\u29DD",
-  ang: "\u2220",
-  angle: "\u2220",
-  angmsd: "\u2221",
-  measuredangle: "\u2221",
-  angsph: "\u2222",
-  mid: "\u2223",
-  VerticalBar: "\u2223",
-  nmid: "\u2224",
-  nsmid: "\u2224",
-  npar: "\u2226",
-  parallel: "\u2225",
-  spar: "\u2225",
-  nparallel: "\u2226",
-  nspar: "\u2226",
-  and: "\u2227",
-  wedge: "\u2227",
-  or: "\u2228",
-  vee: "\u2228",
-  cap: "\u2229",
-  cup: "\u222A",
-  int: "\u222B",
-  Integral: "\u222B",
-  conint: "\u222E",
-  ContourIntegral: "\u222E",
-  Conint: "\u222F",
-  DoubleContourIntegral: "\u222F",
-  Cconint: "\u2230",
-  there4: "\u2234",
-  therefore: "\u2234",
-  Therefore: "\u2234",
-  becaus: "\u2235",
-  because: "\u2235",
-  Because: "\u2235",
-  ratio: "\u2236",
-  Proportion: "\u2237",
-  minusd: "\u2238",
-  dotminus: "\u2238",
-  mDDot: "\u223A",
-  homtht: "\u223B",
-  sim: "\u223C",
-  bsimg: "\u223D",
-  backsim: "\u223D",
-  ac: "\u223E",
-  mstpos: "\u223E",
-  acd: "\u223F",
-  VerticalTilde: "\u2240",
-  wr: "\u2240",
-  wreath: "\u2240",
-  nsime: "\u2244",
-  nsimeq: "\u2244",
-  ncong: "\u2247",
-  simne: "\u2246",
-  ncongdot: "\u2A6D\u0338",
-  ngsim: "\u2275",
-  nsim: "\u2241",
-  napprox: "\u2249",
-  nap: "\u2249",
-  ngeq: "\u2271",
-  nge: "\u2271",
-  nleq: "\u2270",
-  nle: "\u2270",
-  ngtr: "\u226F",
-  ngt: "\u226F",
-  nless: "\u226E",
-  nlt: "\u226E",
-  nprec: "\u2280",
-  npr: "\u2280",
-  nsucc: "\u2281",
-  nsc: "\u2281"
-};
-var ARROWS = {
-  larr: "\u2190",
-  leftarrow: "\u2190",
-  LeftArrow: "\u2190",
-  uarr: "\u2191",
-  uparrow: "\u2191",
-  UpArrow: "\u2191",
-  rarr: "\u2192",
-  rightarrow: "\u2192",
-  RightArrow: "\u2192",
-  darr: "\u2193",
-  downarrow: "\u2193",
-  DownArrow: "\u2193",
-  harr: "\u2194",
-  leftrightarrow: "\u2194",
-  LeftRightArrow: "\u2194",
-  varr: "\u2195",
-  updownarrow: "\u2195",
-  UpDownArrow: "\u2195",
-  nwarr: "\u2196",
-  nwarrow: "\u2196",
-  UpperLeftArrow: "\u2196",
-  nearr: "\u2197",
-  nearrow: "\u2197",
-  UpperRightArrow: "\u2197",
-  searr: "\u2198",
-  searrow: "\u2198",
-  LowerRightArrow: "\u2198",
-  swarr: "\u2199",
-  swarrow: "\u2199",
-  LowerLeftArrow: "\u2199",
-  lArr: "\u21D0",
-  Leftarrow: "\u21D0",
-  uArr: "\u21D1",
-  Uparrow: "\u21D1",
-  rArr: "\u21D2",
-  Rightarrow: "\u21D2",
-  dArr: "\u21D3",
-  Downarrow: "\u21D3",
-  hArr: "\u21D4",
-  Leftrightarrow: "\u21D4",
-  iff: "\u21D4",
-  vArr: "\u21D5",
-  Updownarrow: "\u21D5",
-  lAarr: "\u21DA",
-  Lleftarrow: "\u21DA",
-  rAarr: "\u21DB",
-  Rrightarrow: "\u21DB",
-  lrarr: "\u21C6",
-  leftrightarrows: "\u21C6",
-  rlarr: "\u21C4",
-  rightleftarrows: "\u21C4",
-  lrhar: "\u21CB",
-  leftrightharpoons: "\u21CB",
-  ReverseEquilibrium: "\u21CB",
-  rlhar: "\u21CC",
-  rightleftharpoons: "\u21CC",
-  Equilibrium: "\u21CC",
-  udarr: "\u21C5",
-  UpArrowDownArrow: "\u21C5",
-  duarr: "\u21F5",
-  DownArrowUpArrow: "\u21F5",
-  llarr: "\u21C7",
-  leftleftarrows: "\u21C7",
-  rrarr: "\u21C9",
-  rightrightarrows: "\u21C9",
-  ddarr: "\u21CA",
-  downdownarrows: "\u21CA",
-  har: "\u21BD",
-  lhard: "\u21BD",
-  leftharpoondown: "\u21BD",
-  lharu: "\u21BC",
-  leftharpoonup: "\u21BC",
-  rhard: "\u21C1",
-  rightharpoondown: "\u21C1",
-  rharu: "\u21C0",
-  rightharpoonup: "\u21C0",
-  lsh: "\u21B0",
-  Lsh: "\u21B0",
-  rsh: "\u21B1",
-  Rsh: "\u21B1",
-  ldsh: "\u21B2",
-  rdsh: "\u21B3",
-  hookleftarrow: "\u21A9",
-  hookrightarrow: "\u21AA",
-  mapstoleft: "\u21A4",
-  mapstoup: "\u21A5",
-  map: "\u21A6",
-  mapsto: "\u21A6",
-  mapstodown: "\u21A7",
-  crarr: "\u21B5",
-  nleftarrow: "\u219A",
-  nleftrightarrow: "\u21AE",
-  nrightarrow: "\u219B",
-  nrarr: "\u219B",
-  larrtl: "\u21A2",
-  rarrtl: "\u21A3",
-  leftarrowtail: "\u21A2",
-  rightarrowtail: "\u21A3",
-  twoheadleftarrow: "\u219E",
-  twoheadrightarrow: "\u21A0",
-  Larr: "\u219E",
-  Rarr: "\u21A0",
-  larrhk: "\u21A9",
-  rarrhk: "\u21AA",
-  larrlp: "\u21AB",
-  looparrowleft: "\u21AB",
-  rarrlp: "\u21AC",
-  looparrowright: "\u21AC",
-  harrw: "\u21AD",
-  leftrightsquigarrow: "\u21AD",
-  nrarrw: "\u219D\u0338",
-  rarrw: "\u219D",
-  rightsquigarrow: "\u219D",
-  larrbfs: "\u291F",
-  rarrbfs: "\u2920",
-  nvHarr: "\u2904",
-  nvlArr: "\u2902",
-  nvrArr: "\u2903",
-  larrfs: "\u291D",
-  rarrfs: "\u291E",
-  Map: "\u2905",
-  larrsim: "\u2973",
-  rarrsim: "\u2974",
-  harrcir: "\u2948",
-  Uarrocir: "\u2949",
-  lurdshar: "\u294A",
-  ldrdhar: "\u2967",
-  ldrushar: "\u294B",
-  rdldhar: "\u2969",
-  lrhard: "\u296D",
-  uharr: "\u21BE",
-  uharl: "\u21BF",
-  dharr: "\u21C2",
-  dharl: "\u21C3",
-  Uarr: "\u219F",
-  Darr: "\u21A1",
-  zigrarr: "\u21DD",
-  nwArr: "\u21D6",
-  neArr: "\u21D7",
-  seArr: "\u21D8",
-  swArr: "\u21D9",
-  nharr: "\u21AE",
-  nhArr: "\u21CE",
-  nlarr: "\u219A",
-  nlArr: "\u21CD",
-  nrArr: "\u21CF",
-  larrb: "\u21E4",
-  LeftArrowBar: "\u21E4",
-  rarrb: "\u21E5",
-  RightArrowBar: "\u21E5"
-};
-var SHAPES = {
-  square: "\u25A1",
-  Square: "\u25A1",
-  squ: "\u25A1",
-  squf: "\u25AA",
-  squarf: "\u25AA",
-  blacksquar: "\u25AA",
-  blacksquare: "\u25AA",
-  FilledVerySmallSquare: "\u25AA",
-  blk34: "\u2593",
-  blk12: "\u2592",
-  blk14: "\u2591",
-  block: "\u2588",
-  srect: "\u25AD",
-  rect: "\u25AD",
-  sdot: "\u22C5",
-  sdotb: "\u22A1",
-  dotsquare: "\u22A1",
-  triangle: "\u25B5",
-  tri: "\u25B5",
-  trine: "\u25B5",
-  utri: "\u25B5",
-  triangledown: "\u25BF",
-  dtri: "\u25BF",
-  tridown: "\u25BF",
-  triangleleft: "\u25C3",
-  ltri: "\u25C3",
-  triangleright: "\u25B9",
-  rtri: "\u25B9",
-  blacktriangle: "\u25B4",
-  utrif: "\u25B4",
-  blacktriangledown: "\u25BE",
-  dtrif: "\u25BE",
-  blacktriangleleft: "\u25C2",
-  ltrif: "\u25C2",
-  blacktriangleright: "\u25B8",
-  rtrif: "\u25B8",
-  loz: "\u25CA",
-  lozenge: "\u25CA",
-  blacklozenge: "\u29EB",
-  lozf: "\u29EB",
-  bigcirc: "\u25EF",
-  xcirc: "\u25EF",
-  circ: "\u02C6",
-  Circle: "\u25CB",
-  cir: "\u25CB",
-  o: "\u25CB",
-  bullet: "\u2022",
-  bull: "\u2022",
-  hellip: "\u2026",
-  mldr: "\u2026",
-  nldr: "\u2025",
-  boxh: "\u2500",
-  HorizontalLine: "\u2500",
-  boxv: "\u2502",
-  boxdr: "\u250C",
-  boxdl: "\u2510",
-  boxur: "\u2514",
-  boxul: "\u2518",
-  boxvr: "\u251C",
-  boxvl: "\u2524",
-  boxhd: "\u252C",
-  boxhu: "\u2534",
-  boxvh: "\u253C",
-  boxH: "\u2550",
-  boxV: "\u2551",
-  boxdR: "\u2552",
-  boxDr: "\u2553",
-  boxDR: "\u2554",
-  boxDl: "\u2555",
-  boxdL: "\u2556",
-  boxDL: "\u2557",
-  boxuR: "\u2558",
-  boxUr: "\u2559",
-  boxUR: "\u255A",
-  boxUl: "\u255C",
-  boxuL: "\u255B",
-  boxUL: "\u255D",
-  boxvR: "\u255E",
-  boxVr: "\u255F",
-  boxVR: "\u2560",
-  boxVl: "\u2562",
-  boxvL: "\u2561",
-  boxVL: "\u2563",
-  boxHd: "\u2564",
-  boxhD: "\u2565",
-  boxHD: "\u2566",
-  boxHu: "\u2567",
-  boxhU: "\u2568",
-  boxHU: "\u2569",
-  boxvH: "\u256A",
-  boxVh: "\u256B",
-  boxVH: "\u256C"
-};
-var PUNCTUATION = {
-  excl: "!",
-  iexcl: "\xA1",
-  brvbar: "\xA6",
-  sect: "\xA7",
-  uml: "\xA8",
-  copy: "\xA9",
-  ordf: "\xAA",
-  laquo: "\xAB",
-  not: "\xAC",
-  shy: "\xAD",
-  reg: "\xAE",
-  macr: "\xAF",
-  deg: "\xB0",
-  plusmn: "\xB1",
-  sup2: "\xB2",
-  sup3: "\xB3",
-  acute: "\xB4",
-  micro: "\xB5",
-  para: "\xB6",
-  middot: "\xB7",
-  cedil: "\xB8",
-  sup1: "\xB9",
-  ordm: "\xBA",
-  raquo: "\xBB",
-  frac14: "\xBC",
-  frac12: "\xBD",
-  frac34: "\xBE",
-  iquest: "\xBF",
-  nbsp: "\xA0",
-  comma: ",",
-  period: ".",
-  colon: ":",
-  semi: ";",
-  vert: "|",
-  Verbar: "\u2016",
-  verbar: "|",
-  dblac: "\u02DD",
-  circ: "\u02C6",
-  caron: "\u02C7",
-  breve: "\u02D8",
-  dot: "\u02D9",
-  ring: "\u02DA",
-  ogon: "\u02DB",
-  tilde: "\u02DC",
-  DiacriticalGrave: "`",
-  DiacriticalAcute: "\xB4",
-  DiacriticalTilde: "\u02DC",
-  DiacriticalDot: "\u02D9",
-  DiacriticalDoubleAcute: "\u02DD",
-  grave: "`"
-};
 var CURRENCY = {
   cent: "\xA2",
   pound: "\xA3",
@@ -299591,106 +299430,6 @@ var CURRENCY = {
   yuan: "\xA5",
   cedil: "\xB8"
 };
-var FRACTIONS = {
-  frac12: "\xBD",
-  half: "\xBD",
-  frac13: "\u2153",
-  frac14: "\xBC",
-  frac15: "\u2155",
-  frac16: "\u2159",
-  frac18: "\u215B",
-  frac23: "\u2154",
-  frac25: "\u2156",
-  frac34: "\xBE",
-  frac35: "\u2157",
-  frac38: "\u215C",
-  frac45: "\u2158",
-  frac56: "\u215A",
-  frac58: "\u215D",
-  frac78: "\u215E",
-  frasl: "\u2044"
-};
-var MISC_SYMBOLS = {
-  trade: "\u2122",
-  TRADE: "\u2122",
-  telrec: "\u2315",
-  target: "\u2316",
-  ulcorn: "\u231C",
-  ulcorner: "\u231C",
-  urcorn: "\u231D",
-  urcorner: "\u231D",
-  dlcorn: "\u231E",
-  llcorner: "\u231E",
-  drcorn: "\u231F",
-  lrcorner: "\u231F",
-  intercal: "\u22BA",
-  intcal: "\u22BA",
-  oplus: "\u2295",
-  CirclePlus: "\u2295",
-  ominus: "\u2296",
-  CircleMinus: "\u2296",
-  otimes: "\u2297",
-  CircleTimes: "\u2297",
-  osol: "\u2298",
-  odot: "\u2299",
-  CircleDot: "\u2299",
-  oast: "\u229B",
-  circledast: "\u229B",
-  odash: "\u229D",
-  circleddash: "\u229D",
-  ocirc: "\u229A",
-  circledcirc: "\u229A",
-  boxplus: "\u229E",
-  plusb: "\u229E",
-  boxminus: "\u229F",
-  minusb: "\u229F",
-  boxtimes: "\u22A0",
-  timesb: "\u22A0",
-  boxdot: "\u22A1",
-  sdotb: "\u22A1",
-  veebar: "\u22BB",
-  vee: "\u2228",
-  barvee: "\u22BD",
-  and: "\u2227",
-  wedge: "\u2227",
-  Cap: "\u22D2",
-  Cup: "\u22D3",
-  Fork: "\u22D4",
-  pitchfork: "\u22D4",
-  epar: "\u22D5",
-  ltlarr: "\u2976",
-  nvap: "\u224D\u20D2",
-  nvsim: "\u223C\u20D2",
-  nvge: "\u2265\u20D2",
-  nvle: "\u2264\u20D2",
-  nvlt: "<\u20D2",
-  nvgt: ">\u20D2",
-  nvltrie: "\u22B4\u20D2",
-  nvrtrie: "\u22B5\u20D2",
-  Vdash: "\u22A9",
-  dashv: "\u22A3",
-  vDash: "\u22A8",
-  Vvdash: "\u22AA",
-  nvdash: "\u22AC",
-  nvDash: "\u22AD",
-  nVdash: "\u22AE",
-  nVDash: "\u22AF"
-};
-var ALL_ENTITIES = {
-  ...BASIC_LATIN,
-  ...LATIN_ACCENTS,
-  ...LATIN_EXTENDED,
-  ...GREEK,
-  ...CYRILLIC,
-  ...MATH,
-  ...MATH_ADVANCED,
-  ...ARROWS,
-  ...SHAPES,
-  ...PUNCTUATION,
-  ...CURRENCY,
-  ...FRACTIONS,
-  ...MISC_SYMBOLS
-};
 var XML = {
   amp: "&",
   apos: "'",
@@ -300334,7 +300073,7 @@ var XmlNode = class {
   }
 };
 
-// node_modules/xml-naming/src/index.js
+// node_modules/fast-xml-parser/node_modules/xml-naming/src/index.js
 var nameStartChar10 = ":A-Za-z_\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u0486\u0488-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
 var nameChar10 = nameStartChar10 + "\\-\\.\\d\xB7\u0300-\u036F\u203F-\u2040";
 var nameStartChar11 = ":A-Za-z_\xC0-\u02FF\u0370-\u037D\u037F-\u0486\u0488-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}";
@@ -300353,8 +300092,14 @@ var buildRegexes = (startChar, char, flags = "") => {
 };
 var regexes10 = buildRegexes(nameStartChar10, nameChar10);
 var regexes11 = buildRegexes(nameStartChar11, nameChar11, "u");
-var getRegexes = (xmlVersion = "1.0") => xmlVersion === "1.1" ? regexes11 : regexes10;
-var qName = (str, { xmlVersion = "1.0" } = {}) => getRegexes(xmlVersion).qName.test(str);
+var nameStartCharAscii = ":A-Za-z_";
+var nameCharAscii = nameStartCharAscii + "\\-\\.\\d";
+var regexesAscii = buildRegexes(nameStartCharAscii, nameCharAscii);
+var getRegexes = (xmlVersion = "1.0", asciiOnly = false) => {
+  if (asciiOnly) return regexesAscii;
+  return xmlVersion === "1.1" ? regexes11 : regexes10;
+};
+var qName = (str, { xmlVersion = "1.0", asciiOnly = false } = {}) => getRegexes(xmlVersion, asciiOnly).qName.test(str);
 
 // node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
 var DocTypeReader = class {
@@ -301516,17 +301261,16 @@ var Matcher = class {
       this.path[this.path.length - 1].values = void 0;
     }
     const currentLevel = this.path.length;
-    if (!this.siblingStacks[currentLevel]) {
-      this.siblingStacks[currentLevel] = /* @__PURE__ */ new Map();
+    let level = this.siblingStacks[currentLevel];
+    if (!level) {
+      level = { counts: /* @__PURE__ */ new Map(), total: 0 };
+      this.siblingStacks[currentLevel] = level;
     }
-    const siblings = this.siblingStacks[currentLevel];
     const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
-    const counter = siblings.get(siblingKey) || 0;
-    let position = 0;
-    for (const count of siblings.values()) {
-      position += count;
-    }
-    siblings.set(siblingKey, counter + 1);
+    const counter = level.counts.get(siblingKey) || 0;
+    const position = level.total;
+    level.counts.set(siblingKey, counter + 1);
+    level.total++;
     const node = {
       tag: tagName,
       position,
@@ -301835,7 +301579,7 @@ var Matcher = class {
   snapshot() {
     return {
       path: this.path.map((node) => ({ ...node })),
-      siblingStacks: this.siblingStacks.map((map) => new Map(map)),
+      siblingStacks: this.siblingStacks.map((level) => level ? { counts: new Map(level.counts), total: level.total } : level),
       keptAttrs: this._keptAttrs.map((entry) => ({ ...entry }))
     };
   }
@@ -301846,7 +301590,7 @@ var Matcher = class {
   restore(snapshot) {
     this._pathStringCache = null;
     this.path = snapshot.path.map((node) => ({ ...node }));
-    this.siblingStacks = snapshot.siblingStacks.map((map) => new Map(map));
+    this.siblingStacks = snapshot.siblingStacks.map((level) => level ? { counts: new Map(level.counts), total: level.total } : level);
     this._keptAttrs = (snapshot.keptAttrs || []).map((entry) => ({ ...entry }));
   }
   /**
@@ -302184,27 +301928,6 @@ var SQL_PATTERNS = [
 ];
 var sql_default = SQL_PATTERNS;
 
-// node_modules/is-unsafe/src/contexts/sql-strict.js
-var SQL_STRICT_EXTRA = [
-  {
-    id: "sql-line-comment",
-    description: "SQL line comment: -- followed by whitespace or end of string",
-    pattern: /--(?:\s|$)/
-  },
-  {
-    id: "sql-stacked-query",
-    description: "Stacked queries: semicolon immediately followed by a SQL keyword",
-    pattern: /;\s{0,10}(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC)\b/i
-  },
-  {
-    id: "sql-hex-encoding",
-    description: "Hex-encoded string injection: 0x41414141 style (MySQL)",
-    pattern: /\b0x[0-9a-f]{4,}/i
-  }
-];
-var SQL_STRICT_PATTERNS = [...sql_default, ...SQL_STRICT_EXTRA];
-var sql_strict_default = SQL_STRICT_PATTERNS;
-
 // node_modules/is-unsafe/src/contexts/shell.js
 var SHELL_PATTERNS = [
   {
@@ -302516,8 +302239,38 @@ var LOG_PATTERNS = [
 ];
 var log_default = LOG_PATTERNS;
 
-// node_modules/is-unsafe/src/registry.js
-var CONTEXT_REGISTRY = {
+// node_modules/is-unsafe/src/contexts/sql-strict.js
+var SQL_STRICT_EXTRA = [
+  {
+    id: "sql-line-comment",
+    description: "SQL line comment: -- followed by whitespace or end of string",
+    pattern: /--(?:\s|$)/
+  },
+  {
+    id: "sql-stacked-query",
+    description: "Stacked queries: semicolon immediately followed by a SQL keyword",
+    pattern: /;\s{0,10}(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|EXEC)\b/i
+  },
+  {
+    id: "sql-hex-encoding",
+    description: "Hex-encoded string injection: 0x41414141 style (MySQL)",
+    pattern: /\b0x[0-9a-f]{4,}/i
+  }
+];
+var SQL_STRICT_PATTERNS = [...sql_default, ...SQL_STRICT_EXTRA];
+var sql_strict_default = SQL_STRICT_PATTERNS;
+
+// node_modules/is-unsafe/src/index.js
+html_default.label = "HTML";
+xml_default.label = "XML";
+svg_default.label = "SVG";
+sql_default.label = "SQL";
+sql_strict_default.label = "SQL-STRICT";
+shell_default.label = "SHELL";
+redos_default.label = "REDOS";
+nosql_default.label = "NOSQL";
+log_default.label = "LOG";
+var VALID_CONTEXTS = Object.freeze({
   HTML: html_default,
   XML: xml_default,
   SVG: svg_default,
@@ -302527,13 +302280,7 @@ var CONTEXT_REGISTRY = {
   REDOS: redos_default,
   NOSQL: nosql_default,
   LOG: log_default
-};
-var registry_default = CONTEXT_REGISTRY;
-var VALID_CONTEXTS = Object.freeze(
-  Object.fromEntries(Object.keys(CONTEXT_REGISTRY).map((k) => [k, k]))
-);
-
-// node_modules/is-unsafe/src/index.js
+});
 function assertString(value) {
   if (typeof value !== "string") {
     throw new TypeError(
@@ -302543,36 +302290,35 @@ function assertString(value) {
 }
 function assertContext(context) {
   if (context instanceof RegExp) return;
-  if (typeof context === "string") {
-    if (!registry_default[context]) {
-      throw new TypeError(
-        `is-unsafe: unknown context "${context}". Valid contexts: ${Object.keys(VALID_CONTEXTS).join(", ")}`
-      );
-    }
-    return;
-  }
   if (Array.isArray(context)) {
     if (context.length === 0) {
-      throw new TypeError("is-unsafe: context array must not be empty");
+      throw new TypeError("is-unsafe: context must not be an empty array");
     }
-    for (const c of context) {
-      if (typeof c !== "string" || !registry_default[c]) {
-        throw new TypeError(
-          `is-unsafe: unknown context "${c}" in array. Valid contexts: ${Object.keys(VALID_CONTEXTS).join(", ")}`
-        );
+    if (Array.isArray(context[0])) {
+      for (const list of context) {
+        if (!Array.isArray(list) || list.length === 0) {
+          throw new TypeError(
+            "is-unsafe: each context in the array must be a non-empty pattern array (PatternList)"
+          );
+        }
       }
     }
     return;
   }
   throw new TypeError(
-    `is-unsafe: second argument must be a context string, array of context strings, or RegExp. Got: ${typeof context}`
+    `is-unsafe: second argument must be a PatternList (e.g. HTML), an array of PatternLists (e.g. [HTML, XML]), or a RegExp. Got: ${typeof context}`
   );
 }
-function matchContext(value, contextName) {
-  const patterns = registry_default[contextName];
-  for (const rule of patterns) {
+function normalise(context) {
+  if (context instanceof RegExp) return { lists: null, regex: context };
+  if (Array.isArray(context[0])) return { lists: context, regex: null };
+  return { lists: [context], regex: null };
+}
+function matchList(value, list) {
+  const label = list.label ?? "CUSTOM";
+  for (const rule of list) {
     if (rule.pattern.test(value)) {
-      return { context: contextName, id: rule.id, description: rule.description, pattern: rule.pattern };
+      return { context: label, id: rule.id, description: rule.description, pattern: rule.pattern };
     }
   }
   return null;
@@ -302580,14 +302326,10 @@ function matchContext(value, contextName) {
 function isUnsafe(value, context) {
   assertString(value);
   assertContext(context);
-  if (context instanceof RegExp) {
-    return context.test(value);
-  }
-  if (typeof context === "string") {
-    return matchContext(value, context) !== null;
-  }
-  for (const c of context) {
-    if (matchContext(value, c) !== null) return true;
+  const { lists, regex } = normalise(context);
+  if (regex) return regex.test(value);
+  for (const list of lists) {
+    if (matchList(value, list) !== null) return true;
   }
   return false;
 }
@@ -302636,6 +302378,7 @@ var OrderedObjParser = class {
     this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
     this.entityExpansionCount = 0;
     this.currentExpandedLength = 0;
+    this.doctypefound = false;
     let namedEntities = { ...XML };
     if (this.options.entityDecoder) {
       this.entityDecoder = this.options.entityDecoder;
@@ -302653,7 +302396,7 @@ var OrderedObjParser = class {
         // onExternalEntity: (name, value) => isUnsafe(value) ? 'block' : 'allow',
         onInputEntity: (name, value) => (
           //TODO: VALID_CONTEXTS.HTML should be set only if this.options.htmlEntities
-          isUnsafe(value, [VALID_CONTEXTS.HTML, VALID_CONTEXTS.XML]) ? ENTITY_ACTION.BLOCK : ENTITY_ACTION.ALLOW
+          isUnsafe(value, [html_default, xml_default]) ? ENTITY_ACTION.BLOCK : ENTITY_ACTION.ALLOW
         )
         //postCheck: resolved => resolved
       });
@@ -302787,6 +302530,7 @@ var parseXml = function(xmlData) {
   this.entityDecoder.reset();
   this.entityExpansionCount = 0;
   this.currentExpandedLength = 0;
+  this.doctypefound = false;
   const options = this.options;
   const docTypeReader = new DocTypeReader(options.processEntities);
   const xmlLen = xmlData.length;
@@ -302849,6 +302593,8 @@ var parseXml = function(xmlData) {
         }
         i = endIndex;
       } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 68) {
+        if (this.doctypefound) throw new Error("Multiple DOCTYPE declarations found.");
+        this.doctypefound = true;
         const result = docTypeReader.readDocType(xmlData, i);
         this.entityDecoder.addInputEntities(result.entities);
         i = result.i;
@@ -305440,7 +305186,7 @@ function parseWsdl(content, opts) {
 }
 
 // src/lib/protocols/soap/builder.ts
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var COLLECTION_V210_SCHEMA2 = "https://schema.getpostman.com/json/collection/v2.1.0/collection.json";
 var SOAP11_ENVELOPE_NS = "http://schemas.xmlsoap.org/soap/envelope/";
 var SOAP12_ENVELOPE_NS = "http://www.w3.org/2003/05/soap-envelope";
@@ -305448,7 +305194,7 @@ var SOAP11_CONTENT_TYPE = "text/xml; charset=UTF-8";
 var SOAP12_CONTENT_TYPE = "application/soap+xml; charset=UTF-8";
 var WSA_NS = "http://www.w3.org/2005/08/addressing";
 function stableId2(seed) {
-  return (0, import_node_crypto4.createHash)("sha256").update(seed).digest("hex").slice(0, 32);
+  return (0, import_node_crypto5.createHash)("sha256").update(seed).digest("hex").slice(0, 32);
 }
 function envelopeNamespace(version) {
   return version === "1.2" ? SOAP12_ENVELOPE_NS : SOAP11_ENVELOPE_NS;
@@ -312211,6 +311957,11 @@ function resolveInputs(env = process.env) {
     ),
     protocolEndpointUrl: getInput2("protocol-endpoint-url", env),
     openapiVersion: resolveOpenapiVersion(getInput2("openapi-version", env)),
+    preserveOas30TypeNull: parseBooleanInput(
+      "preserve-oas30-type-null",
+      getInput2("preserve-oas30-type-null", env),
+      false
+    ),
     breakingChangeMode: parseBreakingChangeMode(getInput2("breaking-change-mode", env)),
     breakingBaselineSpecPath: getInput2("breaking-baseline-spec-path", env),
     breakingRulesPath: getInput2("breaking-rules-path", env) ?? bootstrapActionContract.inputs["breaking-rules-path"].default,
@@ -312218,8 +311969,8 @@ function resolveInputs(env = process.env) {
     breakingSummaryPath: getInput2("breaking-summary-path", env),
     breakingLogPath: getInput2("breaking-log-path", env),
     governanceMappingJson: parseGovernanceMappingJson(getInput2("governance-mapping-json", env)),
-    postmanApiKey: getInput2("postman-api-key", env) ?? "",
-    postmanAccessToken: getInput2("postman-access-token", env),
+    postmanApiKey: getInput2("postman-api-key", env) || env.POSTMAN_API_KEY || "",
+    postmanAccessToken: getInput2("postman-access-token", env) || env.POSTMAN_ACCESS_TOKEN,
     credentialPreflight: parseEnumInput(
       "credential-preflight",
       getInput2("credential-preflight", env),
@@ -312241,9 +311992,72 @@ function resolveInputs(env = process.env) {
     githubRef: env.GITHUB_REF,
     githubSha: env.GITHUB_SHA,
     githubToken: getInput2("github-token", env) || env.GITHUB_TOKEN || "",
-    ghFallbackToken: getInput2("gh-fallback-token", env) || env.GH_FALLBACK_TOKEN || ""
+    ghFallbackToken: getInput2("gh-fallback-token", env) || env.GH_FALLBACK_TOKEN || "",
+    branchStrategy: parseEnumInput(
+      "branch-strategy",
+      getInput2("branch-strategy", env),
+      "legacy"
+    ),
+    canonicalBranch: getInput2("canonical-branch", env),
+    channels: getInput2("channels", env)
   };
 }
+function decideBranchTier(inputs, env = process.env) {
+  return resolveEffectiveBranchDecision(
+    {
+      // Tolerate hand-built inputs objects (tests, embedders) that omit the
+      // field: absent means legacy, exactly like the action default.
+      strategy: inputs.branchStrategy ?? "legacy",
+      identity: resolveBranchIdentity(env, { defaultBranch: inputs.canonicalBranch }),
+      canonicalBranch: inputs.canonicalBranch,
+      channels: parseChannelRules(inputs.channels)
+    },
+    env
+  );
+}
+function embedSpecBranchMarker(content, decision, repo) {
+  if (decision.tier !== "preview" && decision.tier !== "channel" || !decision.identity.headBranch || !repo) {
+    return content;
+  }
+  const rawBranch = decision.identity.headBranch;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const marker = {
+    repo,
+    rawBranch,
+    sanitizedBranch: rawBranch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").slice(0, 30),
+    role: decision.tier,
+    headSha: decision.identity.headSha,
+    createdAt: now,
+    lastSyncedAt: now
+  };
+  try {
+    if (content.trim().startsWith("{")) {
+      return `${JSON.stringify({ ...JSON.parse(content), "x-postman-onboarding": marker }, null, 2)}
+`;
+    }
+    const document2 = (0, import_yaml4.parse)(content);
+    if (!document2 || typeof document2 !== "object" || Array.isArray(document2)) return content;
+    return (0, import_yaml4.stringify)({ ...document2, "x-postman-onboarding": marker });
+  } catch {
+    return content;
+  }
+}
+function renderCollectionBranchMarker(decision, repo, now = /* @__PURE__ */ new Date()) {
+  if (decision.tier !== "preview" && decision.tier !== "channel" || !decision.identity.headBranch || !repo) {
+    return void 0;
+  }
+  const rawBranch = decision.identity.headBranch;
+  const timestamp = now.toISOString();
+  return renderAssetMarker({
+    repo,
+    rawBranch,
+    sanitizedBranch: rawBranch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").slice(0, 30),
+    role: decision.tier,
+    headSha: decision.identity.headSha,
+    createdAt: timestamp,
+    lastSyncedAt: timestamp
+  });
+}
 function createPlannedOutputs(inputs) {
   const workspaceName = inputs.domainCode ? `[${inputs.domainCode}] ${inputs.projectName}` : inputs.projectName;
   return {
@@ -312275,7 +312089,12 @@ function createPlannedOutputs(inputs) {
       mode: inputs.breakingChangeMode,
       status: "skipped",
       summaryPath: ""
-    })
+    }),
+    "sync-status": "",
+    "branch-decision": "",
+    "spec-version-tag": "",
+    "spec-version-url": "",
+    "spec-content-changed": ""
   };
 }
 function warnIfDeprecatedAccessToken(actionCore, inputs) {
@@ -312310,11 +312129,8 @@ function readActionInputs(actionCore) {
   if (specUrl && specPath) {
     throw new Error("Provide either spec-url or spec-path, not both.");
   }
-  const postmanApiKey = optionalInput(actionCore, "postman-api-key") ?? "";
-  const postmanAccessToken = optionalInput(actionCore, "postman-access-token");
-  if (!postmanApiKey && !postmanAccessToken) {
-    throw new Error("One of postman-api-key or postman-access-token is required.");
-  }
+  const postmanApiKey = optionalInput(actionCore, "postman-api-key") || process.env.POSTMAN_API_KEY || "";
+  const postmanAccessToken = optionalInput(actionCore, "postman-access-token") || process.env.POSTMAN_ACCESS_TOKEN;
   const githubToken = optionalInput(actionCore, "github-token") || process.env.GITHUB_TOKEN;
   const ghFallbackToken = optionalInput(actionCore, "gh-fallback-token") || process.env.GH_FALLBACK_TOKEN;
   if (postmanApiKey) actionCore.setSecret(postmanApiKey);
@@ -312358,6 +312174,7 @@ function readActionInputs(actionCore) {
     INPUT_NESTED_FOLDER_HIERARCHY: optionalInput(actionCore, "nested-folder-hierarchy") ?? bootstrapActionContract.inputs["nested-folder-hierarchy"].default,
     INPUT_REQUEST_NAME_SOURCE: optionalInput(actionCore, "request-name-source") ?? bootstrapActionContract.inputs["request-name-source"].default,
     INPUT_OPENAPI_VERSION: optionalInput(actionCore, "openapi-version") ?? "",
+    INPUT_PRESERVE_OAS30_TYPE_NULL: optionalInput(actionCore, "preserve-oas30-type-null") ?? bootstrapActionContract.inputs["preserve-oas30-type-null"].default,
     INPUT_BREAKING_CHANGE_MODE: optionalInput(actionCore, "breaking-change-mode") ?? bootstrapActionContract.inputs["breaking-change-mode"].default,
     INPUT_BREAKING_BASELINE_SPEC_PATH: optionalInput(actionCore, "breaking-baseline-spec-path"),
     INPUT_BREAKING_RULES_PATH: optionalInput(actionCore, "breaking-rules-path") ?? bootstrapActionContract.inputs["breaking-rules-path"].default,
@@ -312468,6 +312285,27 @@ async function lintSpecViaCli(dependencies, workspaceId, specId) {
     warnings
   };
 }
+function normalizeLintPath(value) {
+  return value.trim().replace(/^\$\.?/, "").replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+}
+function applyOas30TypeNullLintCompatibility(summary2, sourceTypeNullPaths) {
+  const acceptedPaths = new Set(sourceTypeNullPaths.map(normalizeLintPath));
+  if (acceptedPaths.size === 0) return summary2;
+  const violations = summary2.violations.map((violation) => {
+    const path10 = normalizeLintPath(violation.path ?? "");
+    const issue2 = violation.issue ?? "";
+    const isTypeEnumFinding = /["']?type["']? property/i.test(issue2) && /allowed values|must be equal to one of/i.test(issue2);
+    if (violation.severity === "ERROR" && acceptedPaths.has(path10) && isTypeEnumFinding) {
+      return { ...violation, severity: "WARNING" };
+    }
+    return violation;
+  });
+  return {
+    errors: violations.filter((entry) => entry.severity === "ERROR").length,
+    violations,
+    warnings: violations.filter((entry) => entry.severity === "WARNING").length
+  };
+}
 function shouldRetrySpecFetch(error2) {
   const retryability = classifySafeFetchRetryability(error2);
   return retryability === "retryable" || retryability === "unknown";
@@ -312948,7 +312786,7 @@ async function runProtocolBootstrap(specType, rawSpecContent, inputs, dependenci
     const workspaceRoot = path9.resolve(process.env.GITHUB_WORKSPACE ?? process.cwd());
     const serviceConfigPath = path9.join(path9.dirname(path9.resolve(workspaceRoot, inputs.specPath)), "grpc_service_config.json");
     try {
-      grpcServiceConfigJson = (0, import_node_fs5.readFileSync)(serviceConfigPath, "utf8");
+      grpcServiceConfigJson = (0, import_node_fs6.readFileSync)(serviceConfigPath, "utf8");
       dependencies.core.info(`Found gRPC service config at ${serviceConfigPath}; validating it against the proto contract`);
     } catch {
     }
@@ -312962,7 +312800,7 @@ async function runProtocolBootstrap(specType, rawSpecContent, inputs, dependenci
       const resolved = path9.resolve(specDir, location2);
       if (!resolved.startsWith(specDir + path9.sep)) return void 0;
       try {
-        return (0, import_node_fs5.readFileSync)(resolved, "utf8");
+        return (0, import_node_fs6.readFileSync)(resolved, "utf8");
       } catch {
         return void 0;
       }
@@ -313103,6 +312941,42 @@ async function createExtensibleContractCollection(workspaceId, built, inputs, de
 }
 async function runBootstrapInner(inputs, dependencies, telemetry) {
   const outputs = createPlannedOutputs(inputs);
+  const branchDecision = decideBranchTier(inputs);
+  const isCanonicalWriter = branchDecision.tier === "legacy" || branchDecision.tier === "canonical";
+  const canonicalProjectName = inputs.projectName;
+  const workspaceName = createWorkspaceName(inputs);
+  const aboutText = `Auto-provisioned by Postman for ${inputs.projectName}`;
+  if (branchDecision.tier === "preview" && branchDecision.identity.headBranch) {
+    inputs = {
+      ...inputs,
+      projectName: previewAssetName(inputs.projectName, branchDecision.identity.headBranch)
+    };
+    dependencies.core.info(`branch-aware sync: preview asset set "${inputs.projectName}"`);
+  } else if (branchDecision.tier === "channel" && branchDecision.channel) {
+    inputs = {
+      ...inputs,
+      projectName: channelAssetName(inputs.projectName, branchDecision.channel.code)
+    };
+    dependencies.core.info(`branch-aware sync: channel asset set "${inputs.projectName}"`);
+  }
+  const collectionBranchMarker = renderCollectionBranchMarker(branchDecision, inputs.repoUrl);
+  if (branchDecision.tier !== "legacy") {
+    outputs["sync-status"] = "synced";
+    outputs["branch-decision"] = serializeBranchDecision(branchDecision);
+  }
+  if (!isCanonicalWriter) {
+    const explicitCanonicalIds = [
+      ["spec-id", inputs.specId],
+      ["baseline-collection-id", inputs.baselineCollectionId],
+      ["smoke-collection-id", inputs.smokeCollectionId],
+      ["contract-collection-id", inputs.contractCollectionId]
+    ].filter(([, value]) => Boolean(value));
+    if (explicitCanonicalIds.length > 0) {
+      throw new Error(
+        `CONTRACT_BRANCH_CANONICAL_WRITE: a ${branchDecision.tier} run must not mutate canonical assets, but explicit asset id input(s) were provided: ${explicitCanonicalIds.map(([name]) => name).join(", ")}. Remove them (preview/channel runs discover or create their own suffixed asset sets).`
+      );
+    }
+  }
   const requiresReleaseLabel = inputs.collectionSyncMode === "version" || inputs.specSyncMode === "version";
   const releaseLabel = requiresReleaseLabel ? deriveReleaseLabel(inputs) : void 0;
   if (requiresReleaseLabel && !releaseLabel) {
@@ -313110,11 +312984,23 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       "Versioned spec or collection sync requires a release-label or derivable GitHub ref metadata"
     );
   }
-  const collectionAssetProjectName = inputs.collectionSyncMode === "version" ? createAssetProjectName(inputs, releaseLabel) : inputs.projectName;
-  const workspaceName = createWorkspaceName(inputs);
-  const aboutText = `Auto-provisioned by Postman for ${inputs.projectName}`;
-  const stateStore = resolveResourcesStateStore(dependencies);
-  const resourcesState = stateStore.read();
+  const collectionAssetProjectName = branchDecision.tier === "channel" ? canonicalProjectName : inputs.collectionSyncMode === "version" ? createAssetProjectName(inputs, releaseLabel) : inputs.projectName;
+  const rawStateStore = resolveResourcesStateStore(dependencies);
+  const trackedState = rawStateStore.read();
+  const stateStore = isCanonicalWriter ? rawStateStore : {
+    read: rawStateStore.read,
+    write: () => {
+      dependencies.core.info(
+        `branch-aware sync: skipping .postman/resources.yaml write on ${branchDecision.tier} run (canonical-only tracked state)`
+      );
+    }
+  };
+  const resourcesState = isCanonicalWriter ? trackedState : trackedState?.workspace ? { workspace: trackedState.workspace } : null;
+  if (!isCanonicalWriter && trackedState?.cloudResources) {
+    dependencies.core.info(
+      "branch-aware sync: canonical asset ids in .postman/resources.yaml are not resolved on a non-canonical run"
+    );
+  }
   const writableResourcesState = resourcesState ?? {};
   const additionalCollections = loadAdditionalCollectionFiles(
     inputs.additionalCollectionsDir,
@@ -313134,16 +313020,19 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
   }
   let previousSpecContent;
   let previousSpecRollbackHash;
+  let specContentUnchanged = false;
   let detectedOpenapiVersion = "3.0";
   let contractIndex;
   let sourceSpecContent = "";
+  let sourceTypeNullPaths = [];
+  let preserveSourceSpecBytes = false;
   const rawSpecContent = await runGroup(
     dependencies.core,
     "Read API Spec",
     async () => {
       if (inputs.specPath) {
         const workspaceRoot = path9.resolve(process.env.GITHUB_WORKSPACE ?? process.cwd());
-        return (0, import_node_fs5.readFileSync)(path9.resolve(workspaceRoot, inputs.specPath), "utf8");
+        return (0, import_node_fs6.readFileSync)(path9.resolve(workspaceRoot, inputs.specPath), "utf8");
       }
       if (dependencies.specFetcher === fetch) {
         return safeFetchText(inputs.specUrl, { depth: 0 });
@@ -313179,6 +313068,7 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       };
       const rootKey = inputs.specPath ? void 0 : normalizeRef(inputs.specUrl);
       const loaderOptions = {
+        preserveOas30TypeNull: Boolean(inputs.preserveOas30TypeNull),
         fetchText: async (url, fetchOptions) => {
           if (rootKey && normalizeRef(url) === rootKey) return rawSpecContent;
           if (dependencies.specFetcher === fetch) return safeFetchText(url, fetchOptions);
@@ -313187,6 +313077,8 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       };
       const loaded = inputs.specPath ? await loadOpenApiContractSpecFromPath(inputs.specPath, loaderOptions) : await loadOpenApiContractSpec(inputs.specUrl, loaderOptions);
       sourceSpecContent = loaded.content;
+      sourceTypeNullPaths = loaded.sourceTypeNullPaths;
+      preserveSourceSpecBytes = sourceTypeNullPaths.length > 0;
       const document2 = normalizeSpecDocument(
         loaded.bundledContent,
         (msg) => dependencies.core.warning(msg)
@@ -313209,11 +313101,11 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
             `Unable to verify existing Spec Hub OpenAPI version for spec-id ${specId}; clear spec-id to create a fresh spec`
           );
         }
-        previousSpecContent = normalizeSpecDocument(
+        previousSpecContent = preserveSourceSpecBytes ? previousRaw : normalizeSpecDocument(
           previousRaw,
           (msg) => dependencies.core.warning(`Previous spec normalization: ${msg}`)
         );
-        previousSpecRollbackHash = (0, import_node_crypto5.createHash)("sha256").update(previousSpecContent).digest("hex");
+        previousSpecRollbackHash = (0, import_node_crypto6.createHash)("sha256").update(previousSpecContent).digest("hex");
         const existingSpecType = normalizeSpecTypeFromContent(previousSpecContent);
         if (existingSpecType !== incomingSpecType) {
           throw new Error(
@@ -313224,6 +313116,12 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       dependencies.core.info(
         `Auto-detected OpenAPI version from spec content: ${detectedOpenapiVersion}`
       );
+      if (preserveSourceSpecBytes) {
+        dependencies.core.info(
+          `Preserving original OpenAPI source bytes; accepted ${sourceTypeNullPaths.length} legacy type: null member(s) for internal validation`
+        );
+        return loaded.content;
+      }
       return document2;
     }
   );
@@ -313259,6 +313157,11 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       `OpenAPI breaking-change check failed: ${breakingChangeResult.message || "breaking changes detected"}`
     );
   }
+  const uploadSpecContent = embedSpecBranchMarker(
+    specContent,
+    branchDecision,
+    inputs.repoUrl
+  );
   const provisioned = await provisionWorkspace(
     inputs,
     dependencies,
@@ -313383,10 +313286,17 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
         specId ? "Update Spec in Spec Hub" : "Upload Spec to Spec Hub",
         async () => {
           if (specId) {
-            dependencies.core.info(
-              `Updating existing spec ${specId} (detected version: ${detectedOpenapiVersion}). Note: the spec type (OPENAPI:3.0 / OPENAPI:3.1) is set at creation and cannot be changed on update. If you changed OpenAPI versions, clear the spec-id input to create a fresh spec.`
-            );
-            await dependencies.postman.updateSpec(specId, specContent, workspaceId);
+            if (previousSpecContent !== void 0 && (0, import_node_crypto6.createHash)("sha256").update(uploadSpecContent).digest("hex") === (0, import_node_crypto6.createHash)("sha256").update(previousSpecContent).digest("hex")) {
+              specContentUnchanged = true;
+              dependencies.core.info(
+                `Spec content unchanged (sha256 match); skipping Spec Hub update and version tag for ${specId}.`
+              );
+            } else {
+              dependencies.core.info(
+                `Updating existing spec ${specId} (detected version: ${detectedOpenapiVersion}). Note: the spec type (OPENAPI:3.0 / OPENAPI:3.1) is set at creation and cannot be changed on update. If you changed OpenAPI versions, clear the spec-id input to create a fresh spec.`
+              );
+              await dependencies.postman.updateSpec(specId, uploadSpecContent, workspaceId);
+            }
           } else {
             specId = await dependencies.postman.uploadSpec(
               workspaceId || "",
@@ -313394,7 +313304,7 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
                 inputs,
                 inputs.specSyncMode === "version" ? releaseLabel : void 0
               ),
-              specContent,
+              uploadSpecContent,
               detectedOpenapiVersion
             );
           }
@@ -313411,8 +313321,9 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
         }
       )
     );
+    outputs["spec-content-changed"] = isCanonicalWriter && !specContentUnchanged ? "true" : "false";
     if (lintEnabled) {
-      const lintSummary = await runRollbackStage(
+      let lintSummary = await runRollbackStage(
         "Lint Spec via Postman CLI",
         async () => runGroup(
           dependencies.core,
@@ -313420,6 +313331,16 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
           async () => lintSpecViaCli(dependencies, workspaceId || "", outputs["spec-id"])
         )
       );
+      if (preserveSourceSpecBytes) {
+        const originalErrorCount = lintSummary.errors;
+        lintSummary = applyOas30TypeNullLintCompatibility(lintSummary, sourceTypeNullPaths);
+        const acceptedCount = originalErrorCount - lintSummary.errors;
+        if (acceptedCount > 0) {
+          dependencies.core.info(
+            `Accepted ${acceptedCount} Postman CLI type: null finding(s) covered by preserve-oas30-type-null`
+          );
+        }
+      }
       outputs["lint-summary-json"] = JSON.stringify({
         errors: lintSummary.errors,
         total: lintSummary.violations.length,
@@ -313444,7 +313365,12 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
       });
       dependencies.core.warning("lint skipped: governance errors not enforced (no postman-api-key)");
     }
-    await runRollbackStage(
+    if (specContentUnchanged) {
+      outputs["baseline-collection-id"] = baselineCollectionId || "";
+      outputs["smoke-collection-id"] = smokeCollectionId || "";
+      outputs["contract-collection-id"] = contractCollectionId || "";
+      dependencies.core.info("Spec content unchanged; skipping collection regeneration and version finalization.");
+    } else await runRollbackStage(
       "Generate Collections from Spec",
       async () => runGroup(
         dependencies.core,
@@ -313483,10 +313409,11 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
                 return;
               }
             }
+            const effectivePrefix = branchDecision.tier === "channel" && branchDecision.channel ? channelAssetName(prefix, branchDecision.channel.code).trim() : prefix;
             outputs[outputKey] = await dependencies.postman.generateCollection(
               specId2,
               assetProjectName,
-              prefix,
+              effectivePrefix,
               inputs.folderStrategy,
               inputs.nestedFolderHierarchy,
               inputs.requestNameSource
@@ -313507,6 +313434,32 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
           await ensureCollection(BASELINE_COLLECTION_PREFIX, baselineCollectionId, "baseline-collection-id");
           await ensureCollection(SMOKE_COLLECTION_PREFIX, smokeCollectionId, "smoke-collection-id");
           await ensureCollection(CONTRACT_COLLECTION_PREFIX, contractCollectionId, "contract-collection-id");
+          if (dependencies.postman.adoptGeneratedCollection) {
+            const reelect = async (prefix, outputKey) => {
+              const effectivePrefix = branchDecision.tier === "channel" && branchDecision.channel ? channelAssetName(prefix, branchDecision.channel.code).trim() : prefix;
+              const preferred = outputs[outputKey];
+              if (!preferred) return;
+              outputs[outputKey] = await dependencies.postman.adoptGeneratedCollection(
+                specId2,
+                assetProjectName,
+                effectivePrefix,
+                preferred
+              );
+            };
+            await reelect(BASELINE_COLLECTION_PREFIX, "baseline-collection-id");
+            await reelect(SMOKE_COLLECTION_PREFIX, "smoke-collection-id");
+            await reelect(CONTRACT_COLLECTION_PREFIX, "contract-collection-id");
+          }
+          if (collectionBranchMarker) {
+            if (!dependencies.postman.updateCollectionDescription) {
+              throw new Error("Branch-scoped collections require updateCollectionDescription support");
+            }
+            await Promise.all([
+              outputs["baseline-collection-id"],
+              outputs["smoke-collection-id"],
+              outputs["contract-collection-id"]
+            ].filter(Boolean).map((id) => dependencies.postman.updateCollectionDescription(id, collectionBranchMarker)));
+          }
           if (!dependencies.postman.injectContractTests) {
             throw new Error(
               "Dynamic contract tests require injectContractTests support from the access-token gateway client"
@@ -313609,6 +313562,12 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
               workspaceId: workspaceId || ""
             });
             for (const result of additionalResults) {
+              if (collectionBranchMarker) {
+                if (!dependencies.postman.updateCollectionDescription) {
+                  throw new Error("Branch-scoped collections require updateCollectionDescription support");
+                }
+                await dependencies.postman.updateCollectionDescription(result.collectionId, collectionBranchMarker);
+              }
               completedExternalSideEffects.push(
                 `${result.operation}AdditionalCollection(${result.collectionId} from ${result.displayPath})`
               );
@@ -313684,8 +313643,66 @@ async function runBootstrapInner(inputs, dependencies, telemetry) {
   }
   return outputs;
 }
+async function runGatedValidation(inputs, decision, actionCore) {
+  actionCore.info(`branch-aware sync: gated run (${decision.reason}) \u2014 credential-free static validation, zero workspace writes`);
+  const outputs = createPlannedOutputs(inputs);
+  outputs["sync-status"] = "skipped-branch-gate";
+  outputs["branch-decision"] = serializeBranchDecision(decision);
+  let violations = [];
+  let validated = false;
+  try {
+    let content;
+    if (inputs.specPath) {
+      content = (0, import_node_fs6.readFileSync)(inputs.specPath, "utf8");
+    } else if (inputs.specUrl) {
+      content = await safeFetchText(inputs.specUrl, { depth: 0 });
+    }
+    if (content) {
+      const specType = detectSpecType(content, inputs.specPath);
+      if (specType === "openapi") {
+        const document2 = parseOpenApiDocument(content);
+        const index = buildContractIndex(document2);
+        violations = index.warnings;
+        validated = true;
+      } else {
+        actionCore.info(`branch gate: static lint for spec type ${specType} runs through its protocol builder on publish; parse-only gate applied`);
+        validated = true;
+      }
+    } else {
+      actionCore.info("branch gate: no spec-url/spec-path provided; nothing to validate");
+    }
+  } catch (error2) {
+    throw new Error(
+      `branch gate: static validation failed: ${error2 instanceof Error ? error2.message : String(error2)}`,
+      { cause: error2 }
+    );
+  }
+  outputs["lint-summary-json"] = JSON.stringify({
+    status: validated ? "static-only" : "skipped",
+    reason: "branch-gated run: governance lint requires upload and runs on publish/preview syncs",
+    errors: 0,
+    warnings: violations.length,
+    total: violations.length,
+    violations: violations.map((issue2) => ({ issue: issue2, severity: "WARNING" }))
+  });
+  for (const [name, value] of Object.entries(outputs)) {
+    actionCore.setOutput(name, value);
+  }
+  return outputs;
+}
 async function runAction(actionCore = core_exports, actionExec = exec_exports, actionIo = io_exports) {
   const inputs = readActionInputs(actionCore);
+  const branchDecision = decideBranchTier(inputs);
+  if (branchDecision.tier === "gated") {
+    return runGatedValidation(inputs, branchDecision, actionCore);
+  }
+  if (!inputs.postmanApiKey && !inputs.postmanAccessToken) {
+    throw new Error("One of postman-api-key or postman-access-token is required for a writing sync.");
+  }
+  if (branchDecision.tier !== "legacy") {
+    actionCore.info(`branch-aware sync: tier=${branchDecision.tier} (${branchDecision.reason})`);
+    process.env[BRANCH_DECISION_ENV] = serializeBranchDecision(branchDecision);
+  }
   await mintAccessTokenIfNeeded2(inputs, {
     info: (message) => actionCore.info(message),
     warning: (message) => actionCore.warning(message)
@@ -313762,6 +313779,7 @@ function createRoutingPostmanClient(options) {
       updateSpec: requireAccessToken("updateSpec"),
       getSpecContent: requireAccessToken("getSpecContent"),
       generateCollection: requireAccessToken("generateCollection"),
+      adoptGeneratedCollection: requireAccessToken("adoptGeneratedCollection"),
       createWorkspace: requireAccessToken("createWorkspace"),
       getWorkspaceVisibility: requireAccessToken("getWorkspaceVisibility"),
       getWorkspaceGitRepoUrl: requireAccessToken("getWorkspaceGitRepoUrl"),
@@ -313771,10 +313789,13 @@ function createRoutingPostmanClient(options) {
       inviteRequesterToWorkspace: requireAccessToken("inviteRequesterToWorkspace"),
       injectTests: requireAccessToken("injectTests"),
       tagCollection: requireAccessToken("tagCollection"),
+      tagSpecVersion: requireAccessToken("tagSpecVersion"),
+      listSpecVersionTags: requireAccessToken("listSpecVersionTags"),
       deleteCollection: requireAccessToken("deleteCollection"),
       injectContractTests: requireAccessToken("injectContractTests"),
       createCollection: requireAccessToken("createCollection"),
-      updateCollection: requireAccessToken("updateCollection")
+      updateCollection: requireAccessToken("updateCollection"),
+      updateCollectionDescription: requireAccessToken("updateCollectionDescription")
     };
   }
   return {
@@ -313786,6 +313807,7 @@ function createRoutingPostmanClient(options) {
     // not a reason to reach for the API key.
     uploadSpec: (workspaceId, projectName, specContent, openapiVersion) => gateway.uploadSpec(workspaceId, projectName, specContent, openapiVersion ?? "3.0"),
     generateCollection: (specId, projectName, prefix, folderStrategy, nestedFolderHierarchy, requestNameSource) => gateway.generateCollection(specId, projectName, prefix, folderStrategy, nestedFolderHierarchy, requestNameSource),
+    adoptGeneratedCollection: (specId, projectName, prefix, preferredId) => gateway.adoptGeneratedCollection(specId, projectName, prefix, preferredId),
     updateSpec: (specId, specContent, workspaceId) => gateway.updateSpec(specId, specContent, workspaceId),
     getSpecContent: (specId) => gateway.getSpecContent(specId),
     createWorkspace: (name, about, targetTeamId) => gateway.createWorkspace(name, about, targetTeamId),
@@ -313797,6 +313819,8 @@ function createRoutingPostmanClient(options) {
     // + tagging surfaces (live-proven). PMAK is reserved for token minting, so
     // these never fall back to the API key even when one is present.
     injectTests: (collectionId, type) => gateway.injectTests(collectionId, type),
+    tagSpecVersion: (specId, name) => gateway.tagSpecVersion(specId, name),
+    listSpecVersionTags: (specId) => gateway.listSpecVersionTags(specId),
     tagCollection: (collectionId, tags) => gateway.tagCollection(collectionId, tags),
     // Sub-team (squad) enumeration over the gateway `ums` service. Access-token
     // only — never PMAK — so org-mode detection no longer needs a PMAK GET /teams.
@@ -313814,7 +313838,8 @@ function createRoutingPostmanClient(options) {
     // so no asset op ever reaches for the API key.
     injectContractTests: (collectionUid, index) => gateway.injectContractTests(collectionUid, index),
     createCollection: (workspaceId, collection, options2) => gateway.createCollection(workspaceId, collection, options2),
-    updateCollection: (collectionUid, collection) => gateway.updateCollection(collectionUid, collection)
+    updateCollection: (collectionUid, collection) => gateway.updateCollection(collectionUid, collection),
+    updateCollectionDescription: (collectionUid, description) => gateway.updateCollectionDescription(collectionUid, description)
   };
 }
 function createBootstrapDependencies(inputs, factories, orgMode = false) {