@rockcarver/frodo-cli 4.0.0 → 4.0.1-0

package/dist/app.cjs

@@ -156058,7 +156058,7 @@ function stringify(obj) {
 }
 var package_default = {
   name: "@rockcarver/frodo-lib",
-  version: "4.0.0",
+  version: "4.0.1-6",
   type: "commonjs",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
@@ -177317,8 +177317,8 @@ var ScriptOps_default = (state2) => {
     createScriptExportTemplate() {
       return createScriptExportTemplate({ state: state2 });
     },
-    async readScripts() {
-      return readScripts({ state: state2 });
+    async readScripts(filter2) {
+      return readScripts({ filter: filter2, state: state2 });
     },
     getLibraryScriptNames(scriptObj) {
       return getLibraryScriptNames(scriptObj);
@@ -177341,8 +177341,8 @@ var ScriptOps_default = (state2) => {
     async deleteScriptByName(scriptName) {
       return deleteScriptByName2({ scriptName, state: state2 });
     },
-    async deleteScripts(resultCallback = void 0) {
-      return deleteScripts({ resultCallback, state: state2 });
+    async deleteScripts(resultCallback, filter2) {
+      return deleteScripts({ filter: filter2, resultCallback, state: state2 });
     },
     async exportScript(scriptId, options = {
       deps: true,
@@ -177391,11 +177391,12 @@ function createScriptExportTemplate({
   };
 }
 async function readScripts({
+  filter: filter2,
   state: state2
 }) {
   try {
     const { result } = await getScripts({ state: state2 });
-    return result;
+    return applyScriptFilter(result, filter2);
   } catch (error49) {
     throw new FrodoError(
       `Error reading ${getCurrentRealmName(state2) + " realm"} scripts`,
@@ -177571,10 +177572,11 @@ async function deleteScriptByName2({
   }
 }
 async function deleteScripts({
-  resultCallback = void 0,
+  filter: filter2,
+  resultCallback,
   state: state2
 }) {
-  const result = await readScripts({ state: state2 });
+  const result = await readScripts({ filter: filter2, state: state2 });
   const scripts = result.filter((s4) => !s4.default);
   const deletedScripts = [];
   for (const script of scripts) {
@@ -177646,8 +177648,8 @@ async function exportScripts({
   resultCallback = void 0,
   state: state2
 }) {
-  const { includeDefault, useStringArrays } = options;
-  let scriptList = await readScripts({ state: state2 });
+  const { includeDefault, useStringArrays, filter: filter2 } = options;
+  let scriptList = await readScripts({ filter: filter2, state: state2 });
   if (!includeDefault)
     scriptList = scriptList.filter((script) => !script.default);
   const exportData = createScriptExportTemplate({ state: state2 });
@@ -177701,9 +177703,10 @@ async function importScripts2({
   for (const existingId of Object.keys(importData.script)) {
     try {
       const scriptData = importData.script[existingId];
+      const doesNotMatchFilter = options.filter && !matchesScriptFilter(scriptData, options.filter);
       const isDefault = !options.includeDefault && scriptData.default;
       const shouldNotImportScript = !options.deps && (scriptId && scriptId !== scriptData._id || !scriptId && scriptName && scriptName !== scriptData.name);
-      if (isDefault || shouldNotImportScript) continue;
+      if (isDefault || shouldNotImportScript || doesNotMatchFilter) continue;
       debugMessage({
         message: `ScriptOps.importScripts: Importing script ${scriptData.name} (${existingId})`,
         state: state2
@@ -177747,6 +177750,54 @@ async function importScripts2({
   debugMessage({ message: `ScriptOps.importScripts: end`, state: state2 });
   return response;
 }
+function applyScriptFilter(scripts, filter2) {
+  if (!filter2) return scripts;
+  return scripts.filter((script) => matchesScriptFilter(script, filter2));
+}
+function matchesScriptFilter(script, filter2) {
+  if (!filter2) return true;
+  if ("filters" in filter2) {
+    const filters = _nullishCoalesce(filter2.filters, () => ( []));
+    const operator = _nullishCoalesce(filter2.operator, () => ( "AND"));
+    if (filters.length === 0) return true;
+    return operator === "OR" ? filters.some(
+      (nestedFilter) => matchesScriptFilter(script, nestedFilter)
+    ) : filters.every(
+      (nestedFilter) => matchesScriptFilter(script, nestedFilter)
+    );
+  }
+  const expectedValues = normalizeFilterValues(filter2.value);
+  const actualValues = getScriptFilterValues(script, filter2.field);
+  return actualValues.some(
+    (actualValue) => expectedValues.includes(actualValue)
+  );
+}
+function getScriptFilterValues(script, field) {
+  const normalizedField = field.trim().toUpperCase();
+  switch (normalizedField) {
+    case "LANGUAGE":
+      return normalizeFilterValues(script.language);
+    case "CONTEXT":
+    case "USE":
+      return normalizeFilterValues(script.context);
+    case "EVALUATORVERSION":
+      return normalizeFilterValues(_nullishCoalesce(script.evaluatorVersion, () => ( "1.0")));
+    default: {
+      const rawValue = _optionalChain([Object, 'access', _177 => _177.entries, 'call', _178 => _178(script), 'access', _179 => _179.find, 'call', _180 => _180(
+        ([key]) => key.toUpperCase() === normalizedField
+      ), 'optionalAccess', _181 => _181[1]]);
+      return normalizeFilterValues(rawValue);
+    }
+  }
+}
+function normalizeFilterValues(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => normalizeFilterValues(entry));
+  }
+  if (value === null || value === void 0) return [];
+  const normalizedValue = String(value).trim().toUpperCase();
+  return normalizedValue ? [normalizedValue] : [];
+}
 async function prepareScriptExport({
   scriptData,
   options = {
@@ -177857,7 +177908,7 @@ async function readOAuth2Clients({
     const clients = (await getOAuth2Clients({ state: state2 })).result;
     return clients;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _177 => _177.response, 'optionalAccess', _178 => _178.status]) === 403 && _optionalChain([error49, 'access', _179 => _179.response, 'optionalAccess', _180 => _180.data, 'optionalAccess', _181 => _181.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+    if (_optionalChain([error49, 'access', _182 => _182.response, 'optionalAccess', _183 => _183.status]) === 403 && _optionalChain([error49, 'access', _184 => _184.response, 'optionalAccess', _185 => _185.data, 'optionalAccess', _186 => _186.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
       return [];
     } else {
       throw new FrodoError(
@@ -177926,7 +177977,7 @@ async function updateOAuth2Client({
     debugMessage({ message: `OAuth2ClientOps.putOAuth2Client: end`, state: state2 });
     return response;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _182 => _182.response, 'optionalAccess', _183 => _183.status]) === 400 && _optionalChain([error49, 'access', _184 => _184.response, 'optionalAccess', _185 => _185.data, 'optionalAccess', _186 => _186.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([error49, 'access', _187 => _187.response, 'optionalAccess', _188 => _188.status]) === 400 && _optionalChain([error49, 'access', _189 => _189.response, 'optionalAccess', _190 => _190.data, 'optionalAccess', _191 => _191.message]) === "Invalid attribute specified.") {
       try {
         const { validAttributes } = error49.response.data.detail;
         sanitizeOAuth2ClientInvalidAttributes({
@@ -178710,7 +178761,7 @@ async function readOAuth2TrustedJwtIssuers({
     const issuers = (await getOAuth2TrustedJwtIssuers({ state: state2 })).result;
     return issuers;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _187 => _187.response, 'optionalAccess', _188 => _188.status]) === 403 && _optionalChain([error49, 'access', _189 => _189.response, 'optionalAccess', _190 => _190.data, 'optionalAccess', _191 => _191.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+    if (_optionalChain([error49, 'access', _192 => _192.response, 'optionalAccess', _193 => _193.status]) === 403 && _optionalChain([error49, 'access', _194 => _194.response, 'optionalAccess', _195 => _195.data, 'optionalAccess', _196 => _196.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
       return [];
     } else {
       throw new FrodoError(
@@ -178788,7 +178839,7 @@ async function updateOAuth2TrustedJwtIssuer({
     });
     return response;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _192 => _192.response, 'optionalAccess', _193 => _193.status]) === 400 && _optionalChain([error49, 'access', _194 => _194.response, 'optionalAccess', _195 => _195.data, 'optionalAccess', _196 => _196.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([error49, 'access', _197 => _197.response, 'optionalAccess', _198 => _198.status]) === 400 && _optionalChain([error49, 'access', _199 => _199.response, 'optionalAccess', _200 => _200.data, 'optionalAccess', _201 => _201.message]) === "Invalid attribute specified.") {
       try {
         const { validAttributes } = error49.response.data.detail;
         validAttributes.push("_id");
@@ -180659,13 +180710,13 @@ async function countManagedObjects({
   const { data: data2 } = await generateIdmApi({ requestOverride: {}, state: state2 }).get(
     urlString
   );
-  if (typeof _optionalChain([data2, 'optionalAccess', _197 => _197.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _202 => _202.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
     return data2.totalPagedResults;
   }
-  if (typeof _optionalChain([data2, 'optionalAccess', _198 => _198.resultCount]) === "number" && data2.resultCount >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _203 => _203.resultCount]) === "number" && data2.resultCount >= 0) {
     return data2.resultCount;
   }
-  return Array.isArray(_optionalChain([data2, 'optionalAccess', _199 => _199.result])) ? data2.result.length : 0;
+  return Array.isArray(_optionalChain([data2, 'optionalAccess', _204 => _204.result])) ? data2.result.length : 0;
 }
 async function queryAllManagedObjectsByType({
   type,
@@ -180827,7 +180878,7 @@ async function readManagedObjectSchema({
     if (options.excludeRelationships) {
       for (const prop in schema.properties) {
         if (schema.properties[prop]["type"] === "relationship" || schema.properties[prop]["type"] === "array" && schema.properties[prop]["items"] && schema.properties[prop]["items"]["type"] === "relationship") {
-          const resourcePath = _optionalChain([schema, 'access', _200 => _200.properties, 'access', _201 => _201[prop], 'access', _202 => _202["resourceCollection"], 'optionalAccess', _203 => _203[0], 'optionalAccess', _204 => _204["path"]]);
+          const resourcePath = _optionalChain([schema, 'access', _205 => _205.properties, 'access', _206 => _206[prop], 'access', _207 => _207["resourceCollection"], 'optionalAccess', _208 => _208[0], 'optionalAccess', _209 => _209["path"]]);
           debugMessage({
             message: `ManagedObjectOps.readManagedObjectSchema: Found relationship property "${prop}" with resource path "${resourcePath}" in schema for type "${type}"`,
             state: state2
@@ -181448,7 +181499,7 @@ function sanitizeAIAgentPayload(agentData) {
   return sanitized;
 }
 function isAlreadyExistsError(error49) {
-  return _optionalChain([error49, 'optionalAccess', _205 => _205.httpStatus]) === 409 || _optionalChain([error49, 'optionalAccess', _206 => _206.httpStatus]) === 412 || _optionalChain([error49, 'optionalAccess', _207 => _207.response, 'optionalAccess', _208 => _208.status]) === 409 || _optionalChain([error49, 'optionalAccess', _209 => _209.response, 'optionalAccess', _210 => _210.status]) === 412;
+  return _optionalChain([error49, 'optionalAccess', _210 => _210.httpStatus]) === 409 || _optionalChain([error49, 'optionalAccess', _211 => _211.httpStatus]) === 412 || _optionalChain([error49, 'optionalAccess', _212 => _212.response, 'optionalAccess', _213 => _213.status]) === 409 || _optionalChain([error49, 'optionalAccess', _214 => _214.response, 'optionalAccess', _215 => _215.status]) === 412;
 }
 var AgentTypeItemCache = [];
 var AgentTypeBlacklist = ["OAuth2Client"];
@@ -181479,7 +181530,7 @@ async function readAgentTypes({
     debugMessage({ message: `AgentOps.readAgentTypes: end`, state: state2 });
     return agentTypeItems.map((item) => item._id);
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _211 => _211.response, 'optionalAccess', _212 => _212.status]) === 403 && _optionalChain([error49, 'access', _213 => _213.response, 'optionalAccess', _214 => _214.data, 'optionalAccess', _215 => _215.message]) === "This operation is not available in PingOne Advanced Identity Cloud." || _optionalChain([error49, 'access', _216 => _216.response, 'optionalAccess', _217 => _217.status]) === 404) {
+    if (_optionalChain([error49, 'access', _216 => _216.response, 'optionalAccess', _217 => _217.status]) === 403 && _optionalChain([error49, 'access', _218 => _218.response, 'optionalAccess', _219 => _219.data, 'optionalAccess', _220 => _220.message]) === "This operation is not available in PingOne Advanced Identity Cloud." || _optionalChain([error49, 'access', _221 => _221.response, 'optionalAccess', _222 => _222.status]) === 404) {
       return [];
     } else {
       throw new FrodoError(
@@ -181514,7 +181565,7 @@ async function readAgents({
     debugMessage({ message: `AgentOps.readAgents: end`, state: state2 });
     return agents;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _218 => _218.response, 'optionalAccess', _219 => _219.status]) === 403 && _optionalChain([error49, 'access', _220 => _220.response, 'optionalAccess', _221 => _221.data, 'optionalAccess', _222 => _222.message]) === "This operation is not available in PingOne Advanced Identity Cloud." || _optionalChain([error49, 'access', _223 => _223.response, 'optionalAccess', _224 => _224.status]) === 404) {
+    if (_optionalChain([error49, 'access', _223 => _223.response, 'optionalAccess', _224 => _224.status]) === 403 && _optionalChain([error49, 'access', _225 => _225.response, 'optionalAccess', _226 => _226.data, 'optionalAccess', _227 => _227.message]) === "This operation is not available in PingOne Advanced Identity Cloud." || _optionalChain([error49, 'access', _228 => _228.response, 'optionalAccess', _229 => _229.status]) === 404) {
       return [];
     } else {
       throw new FrodoError(
@@ -181717,7 +181768,7 @@ async function importAgents({
           })
         );
       } catch (error49) {
-        if (error49.httpStatus !== 501 && _optionalChain([error49, 'access', _225 => _225.response, 'optionalAccess', _226 => _226.status]) !== 501) {
+        if (error49.httpStatus !== 501 && _optionalChain([error49, 'access', _230 => _230.response, 'optionalAccess', _231 => _231.status]) !== 501) {
           errors.push(
             new FrodoError(
               `Error importing ${getCurrentRealmName(state2) + " realm"} agent ${agentId} of type ${agentType}`,
@@ -181753,7 +181804,7 @@ async function importAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _227 => _227.agent, 'access', _228 => _228[agentId], 'optionalAccess', _229 => _229._type, 'access', _230 => _230._id]);
+    const agentType = _optionalChain([importData, 'access', _232 => _232.agent, 'access', _233 => _233[agentId], 'optionalAccess', _234 => _234._type, 'access', _235 => _235._id]);
     if (agentType === "SoapSTSAgent" && state2.getDeploymentType() !== Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY) {
       throw new FrodoError(
         `Can't import Soap STS agents for '${state2.getDeploymentType()}' deployment type.`
@@ -182126,7 +182177,7 @@ async function importIdentityGatewayAgent({
       message: `AgentOps.importIdentityGatewayAgent: start`,
       state: state2
     });
-    const agentType = _optionalChain([importData, 'access', _231 => _231.agent, 'access', _232 => _232[agentId], 'optionalAccess', _233 => _233._type, 'access', _234 => _234._id]);
+    const agentType = _optionalChain([importData, 'access', _236 => _236.agent, 'access', _237 => _237[agentId], 'optionalAccess', _238 => _238._type, 'access', _239 => _239._id]);
     if (agentType !== "IdentityGatewayAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'IdentityGatewayAgent' but got '${agentType}'.`
@@ -182433,7 +182484,7 @@ async function importJavaAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importJavaAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _235 => _235.agent, 'access', _236 => _236[agentId], 'optionalAccess', _237 => _237._type, 'access', _238 => _238._id]);
+    const agentType = _optionalChain([importData, 'access', _240 => _240.agent, 'access', _241 => _241[agentId], 'optionalAccess', _242 => _242._type, 'access', _243 => _243._id]);
     if (agentType !== "J2EEAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'J2EEAgent' but got '${agentType}'.`
@@ -182735,7 +182786,7 @@ async function importWebAgent({
 }) {
   try {
     debugMessage({ message: `AgentOps.importWebAgent: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _239 => _239.agent, 'access', _240 => _240[agentId], 'optionalAccess', _241 => _241._type, 'access', _242 => _242._id]);
+    const agentType = _optionalChain([importData, 'access', _244 => _244.agent, 'access', _245 => _245[agentId], 'optionalAccess', _246 => _246._type, 'access', _247 => _247._id]);
     if (agentType !== "WebAgent")
       throw new FrodoError(
         `Wrong agent type! Expected 'WebAgent' but got '${agentType}'.`
@@ -183446,7 +183497,7 @@ async function importAIAgent({
       message: `AgentOps.importAIAgent: start [includeAgentIdentity=${includeAgentIdentity}]`,
       state: state2
     });
-    const agentType = _optionalChain([importData, 'access', _243 => _243.agent, 'access', _244 => _244[agentId], 'optionalAccess', _245 => _245._type, 'access', _246 => _246._id]);
+    const agentType = _optionalChain([importData, 'access', _248 => _248.agent, 'access', _249 => _249[agentId], 'optionalAccess', _250 => _250._type, 'access', _251 => _251._id]);
     if (agentType !== "AIAgent") {
       throw new FrodoError(
         `Wrong agent type! Expected 'AIAgent' but got '${agentType}'.`
@@ -183494,7 +183545,7 @@ async function readAgentGroups({
     const { result } = await getAgentGroups({ state: state2 });
     return result;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _247 => _247.response, 'optionalAccess', _248 => _248.status]) === 403 && _optionalChain([error49, 'access', _249 => _249.response, 'optionalAccess', _250 => _250.data, 'optionalAccess', _251 => _251.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+    if (_optionalChain([error49, 'access', _252 => _252.response, 'optionalAccess', _253 => _253.status]) === 403 && _optionalChain([error49, 'access', _254 => _254.response, 'optionalAccess', _255 => _255.data, 'optionalAccess', _256 => _256.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
       return [];
     } else {
       throw new FrodoError(
@@ -183597,7 +183648,7 @@ async function importAgentGroups({
           })
         );
       } catch (error49) {
-        if (error49.httpStatus !== 501 && _optionalChain([error49, 'access', _252 => _252.response, 'optionalAccess', _253 => _253.status]) !== 501) {
+        if (error49.httpStatus !== 501 && _optionalChain([error49, 'access', _257 => _257.response, 'optionalAccess', _258 => _258.status]) !== 501) {
           errors.push(
             new FrodoError(
               `Error importing ${getCurrentRealmName(state2) + " realm"} agent group ${agentGroupId} of type ${agentType}`,
@@ -183632,7 +183683,7 @@ async function importAgentGroup({
 }) {
   try {
     debugMessage({ message: `AgentOps.importAgentGroup: start`, state: state2 });
-    const agentType = _optionalChain([importData, 'access', _254 => _254.agentGroup, 'access', _255 => _255[agentGroupId], 'optionalAccess', _256 => _256._type, 'access', _257 => _257._id]);
+    const agentType = _optionalChain([importData, 'access', _259 => _259.agentGroup, 'access', _260 => _260[agentGroupId], 'optionalAccess', _261 => _261._type, 'access', _262 => _262._id]);
     if (agentType === "SoapSTSAgent" && state2.getDeploymentType() !== Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY) {
       throw new FrodoError(
         `Can't import Soap STS agent groups for '${state2.getDeploymentType()}' deployment type.`
@@ -184838,7 +184889,7 @@ async function readSaml2ProviderStubs({
   } catch (error49) {
     if (
       // operation is not available in PingOne Advanced Identity Cloud
-      _optionalChain([error49, 'access', _258 => _258.response, 'optionalAccess', _259 => _259.status]) === 403 && _optionalChain([error49, 'access', _260 => _260.response, 'optionalAccess', _261 => _261.data, 'optionalAccess', _262 => _262.message]) === "This operation is not available in PingOne Advanced Identity Cloud."
+      _optionalChain([error49, 'access', _263 => _263.response, 'optionalAccess', _264 => _264.status]) === 403 && _optionalChain([error49, 'access', _265 => _265.response, 'optionalAccess', _266 => _266.data, 'optionalAccess', _267 => _267.message]) === "This operation is not available in PingOne Advanced Identity Cloud."
     ) {
       return [];
     } else {
@@ -185615,7 +185666,7 @@ async function createCircleOfTrust2({
     const response = await createCircleOfTrust({ cotData, state: state2 });
     return response;
   } catch (createError) {
-    if (_optionalChain([createError, 'access', _263 => _263.response, 'optionalAccess', _264 => _264.data, 'optionalAccess', _265 => _265.code]) === 500 && _optionalChain([createError, 'access', _266 => _266.response, 'optionalAccess', _267 => _267.data, 'optionalAccess', _268 => _268.message]) === "Unable to update entity provider's circle of trust") {
+    if (_optionalChain([createError, 'access', _268 => _268.response, 'optionalAccess', _269 => _269.data, 'optionalAccess', _270 => _270.code]) === 500 && _optionalChain([createError, 'access', _271 => _271.response, 'optionalAccess', _272 => _272.data, 'optionalAccess', _273 => _273.message]) === "Unable to update entity provider's circle of trust") {
       try {
         const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
         return response;
@@ -185642,7 +185693,7 @@ async function updateCircleOfTrust2({
     const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
     return response || cotData;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _269 => _269.response, 'optionalAccess', _270 => _270.data, 'optionalAccess', _271 => _271.code]) === 500 && (_optionalChain([error49, 'access', _272 => _272.response, 'optionalAccess', _273 => _273.data, 'optionalAccess', _274 => _274.message]) === "Unable to update entity provider's circle of trust" || _optionalChain([error49, 'access', _275 => _275.response, 'optionalAccess', _276 => _276.data, 'optionalAccess', _277 => _277.message]) === "An error occurred while updating the COT memberships")) {
+    if (_optionalChain([error49, 'access', _274 => _274.response, 'optionalAccess', _275 => _275.data, 'optionalAccess', _276 => _276.code]) === 500 && (_optionalChain([error49, 'access', _277 => _277.response, 'optionalAccess', _278 => _278.data, 'optionalAccess', _279 => _279.message]) === "Unable to update entity provider's circle of trust" || _optionalChain([error49, 'access', _280 => _280.response, 'optionalAccess', _281 => _281.data, 'optionalAccess', _282 => _282.message]) === "An error occurred while updating the COT memberships")) {
       try {
         const response = await updateCircleOfTrust({ cotId, cotData, state: state2 });
         return response || cotData;
@@ -186067,7 +186118,7 @@ ${providers.map((it) => it.split("|")[0]).join("\n")}.`,
         }
       } catch (error49) {
         debugMessage({
-          message: `Error ${_optionalChain([error49, 'access', _278 => _278.response, 'optionalAccess', _279 => _279.status])} creating/updating ${getCurrentRealmName(state2) + " realm"} circle of trust: ${_optionalChain([error49, 'access', _280 => _280.response, 'optionalAccess', _281 => _281.data, 'optionalAccess', _282 => _282.message])}`,
+          message: `Error ${_optionalChain([error49, 'access', _283 => _283.response, 'optionalAccess', _284 => _284.status])} creating/updating ${getCurrentRealmName(state2) + " realm"} circle of trust: ${_optionalChain([error49, 'access', _285 => _285.response, 'optionalAccess', _286 => _286.data, 'optionalAccess', _287 => _287.message])}`,
           state: state2
         });
         errors.push(error49);
@@ -186400,7 +186451,7 @@ async function importGlossarySchemas({
           state: state2
         });
       } catch (error49) {
-        if (_optionalChain([error49, 'access', _283 => _283.response, 'optionalAccess', _284 => _284.status]) === 500 && _optionalChain([error49, 'access', _285 => _285.response, 'optionalAccess', _286 => _286.data, 'optionalAccess', _287 => _287.message]) === `Cannot read properties of undefined (reading '_source')`) {
+        if (_optionalChain([error49, 'access', _288 => _288.response, 'optionalAccess', _289 => _289.status]) === 500 && _optionalChain([error49, 'access', _290 => _290.response, 'optionalAccess', _291 => _291.data, 'optionalAccess', _292 => _292.message]) === `Cannot read properties of undefined (reading '_source')`) {
           result = await createGlossarySchema2({
             glossarySchemaData: glossarySchema,
             state: state2
@@ -186669,7 +186720,7 @@ async function createRequestType2({
   state: state2
 }) {
   try {
-    if (Array.isArray(_optionalChain([typeData, 'access', _288 => _288.validation, 'optionalAccess', _289 => _289.source]))) {
+    if (Array.isArray(_optionalChain([typeData, 'access', _293 => _293.validation, 'optionalAccess', _294 => _294.source]))) {
       typeData.validation.source = typeData.validation.source.join("\n");
     }
     return await createRequestType({ typeData, state: state2 });
@@ -186831,7 +186882,7 @@ async function updateRequestType({
   state: state2
 }) {
   try {
-    if (Array.isArray(_optionalChain([typeData, 'access', _290 => _290.validation, 'optionalAccess', _291 => _291.source]))) {
+    if (Array.isArray(_optionalChain([typeData, 'access', _295 => _295.validation, 'optionalAccess', _296 => _296.source]))) {
       typeData.validation.source = typeData.validation.source.join("\n");
     }
     return await putRequestType({
@@ -187907,7 +187958,7 @@ async function importEvents({
           state: state2
         });
       } catch (error49) {
-        if (_optionalChain([error49, 'access', _292 => _292.response, 'optionalAccess', _293 => _293.status]) === 404 && _optionalChain([error49, 'access', _294 => _294.response, 'optionalAccess', _295 => _295.data, 'optionalAccess', _296 => _296.message]) && error49.response.data.message.startsWith("Cannot find event with id")) {
+        if (_optionalChain([error49, 'access', _297 => _297.response, 'optionalAccess', _298 => _298.status]) === 404 && _optionalChain([error49, 'access', _299 => _299.response, 'optionalAccess', _300 => _300.data, 'optionalAccess', _301 => _301.message]) && error49.response.data.message.startsWith("Cannot find event with id")) {
           result = await createEvent2({
             eventData,
             state: state2
@@ -187985,7 +188036,7 @@ async function prepareEventForExport({
   const exportData = createEventExportTemplate({ state: state2 });
   if (options.deps) {
     const templates = await getIGANotificationEmailTemplateDependencies(
-      _optionalChain([eventData, 'access', _297 => _297.action, 'optionalAccess', _298 => _298.template]),
+      _optionalChain([eventData, 'access', _302 => _302.action, 'optionalAccess', _303 => _303.template]),
       state2
     );
     exportData.emailTemplate = Object.fromEntries(
@@ -188371,12 +188422,12 @@ async function importWorkflows({
         state: state2
       });
       if (!workflow.draft) {
-        workflow.draft = _optionalChain([serverWorkflows, 'access', _299 => _299[workflow.published.id], 'optionalAccess', _300 => _300.draft]);
+        workflow.draft = _optionalChain([serverWorkflows, 'access', _304 => _304[workflow.published.id], 'optionalAccess', _305 => _305.draft]);
       }
       if (workflow.published) {
         fillCoordinates(
           workflow.published,
-          _optionalChain([serverWorkflows, 'access', _301 => _301[workflow.published.id], 'optionalAccess', _302 => _302.published])
+          _optionalChain([serverWorkflows, 'access', _306 => _306[workflow.published.id], 'optionalAccess', _307 => _307.published])
         );
         const result = await updateWorkflow({
           workflowId: workflow.published.id,
@@ -188391,7 +188442,7 @@ async function importWorkflows({
       if (workflow.draft) {
         fillCoordinates(
           workflow.draft,
-          _optionalChain([serverWorkflows, 'access', _303 => _303[workflow.draft.id], 'optionalAccess', _304 => _304.draft])
+          _optionalChain([serverWorkflows, 'access', _308 => _308[workflow.draft.id], 'optionalAccess', _309 => _309.draft])
         );
         const result = await updateWorkflow({
           workflowId: workflow.draft.id,
@@ -188669,13 +188720,13 @@ async function readGroupedWorkflows({
   try {
     workflow.draft = await getDraftWorkflow({ workflowId, state: state2 });
   } catch (e) {
-    if (_optionalChain([e, 'access', _305 => _305.response, 'optionalAccess', _306 => _306.status]) !== 404)
+    if (_optionalChain([e, 'access', _310 => _310.response, 'optionalAccess', _311 => _311.status]) !== 404)
       throw new FrodoError(`Error reading draft workflow ${workflowId}`, e);
   }
   try {
     workflow.published = await getPublishedWorkflow({ workflowId, state: state2 });
   } catch (e) {
-    if (_optionalChain([e, 'access', _307 => _307.response, 'optionalAccess', _308 => _308.status]) !== 404)
+    if (_optionalChain([e, 'access', _312 => _312.response, 'optionalAccess', _313 => _313.status]) !== 404)
       throw new FrodoError(`Error reading published workflow ${workflowId}`, e);
   }
   return { [workflowId]: workflow };
@@ -189290,8 +189341,8 @@ function noLegacySyncMappings(error49) {
       continue;
     }
     visited.add(current);
-    const status = _optionalChain([current, 'access', _309 => _309.response, 'optionalAccess', _310 => _310.status]);
-    const url42 = _optionalChain([current, 'access', _311 => _311.config, 'optionalAccess', _312 => _312.url]);
+    const status = _optionalChain([current, 'access', _314 => _314.response, 'optionalAccess', _315 => _315.status]);
+    const url42 = _optionalChain([current, 'access', _316 => _316.config, 'optionalAccess', _317 => _317.url]);
     if (status === 404 && typeof url42 === "string" && /\/openidm\/config\/sync(?:\?|$)/.test(url42)) {
       return true;
     }
@@ -189774,7 +189825,7 @@ async function importFirstMapping({
   const imported = [];
   const mappingIds = Object.keys(importData.mapping);
   let mappingId;
-  if (_optionalChain([importData, 'access', _313 => _313.sync, 'optionalAccess', _314 => _314.mappings, 'optionalAccess', _315 => _315.length]) > 0) {
+  if (_optionalChain([importData, 'access', _318 => _318.sync, 'optionalAccess', _319 => _319.mappings, 'optionalAccess', _320 => _320.length]) > 0) {
     mappingId = importData.sync.mappings[0]._id;
   } else if (mappingIds.length > 0) {
     mappingId = mappingIds[0];
@@ -191419,7 +191470,7 @@ async function readApplicationGlossary({
       state: state2
     });
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _316 => _316.response, 'optionalAccess', _317 => _317.status]) !== 404) {
+    if (_optionalChain([error49, 'access', _321 => _321.response, 'optionalAccess', _322 => _322.status]) !== 404) {
       throw error49;
     }
   }
@@ -191580,7 +191631,7 @@ async function readFeatures({
     const { result } = await getFeatures({ state: state2 });
     state2.setFeatures(JSON.parse(JSON.stringify(result)));
   } catch (error49) {
-    debugMessage({ message: _optionalChain([error49, 'access', _318 => _318.response, 'optionalAccess', _319 => _319.data]), state: state2 });
+    debugMessage({ message: _optionalChain([error49, 'access', _323 => _323.response, 'optionalAccess', _324 => _324.data]), state: state2 });
     state2.setFeatures([]);
   }
   return state2.getFeatures();
@@ -193419,7 +193470,7 @@ async function determineDeploymentType(state2) {
           state: state2
         });
       } catch (e) {
-        if (_optionalChain([e, 'access', _320 => _320.response, 'optionalAccess', _321 => _321.status]) === 302 && _optionalChain([e, 'access', _322 => _322.response, 'access', _323 => _323.headers, 'optionalAccess', _324 => _324.location, 'optionalAccess', _325 => _325.indexOf, 'call', _326 => _326("code=")]) > -1) {
+        if (_optionalChain([e, 'access', _325 => _325.response, 'optionalAccess', _326 => _326.status]) === 302 && _optionalChain([e, 'access', _327 => _327.response, 'access', _328 => _328.headers, 'optionalAccess', _329 => _329.location, 'optionalAccess', _330 => _330.indexOf, 'call', _331 => _331("code=")]) > -1) {
           verboseMessage({
             message: C.cyan(`ForgeRock Identity Cloud`) + ` detected.`,
             state: state2
@@ -193435,7 +193486,7 @@ async function determineDeploymentType(state2) {
               state: state2
             });
           } catch (ex) {
-            if (_optionalChain([ex, 'access', _327 => _327.response, 'optionalAccess', _328 => _328.status]) === 302 && _optionalChain([ex, 'access', _329 => _329.response, 'access', _330 => _330.headers, 'optionalAccess', _331 => _331.location, 'optionalAccess', _332 => _332.indexOf, 'call', _333 => _333("code=")]) > -1) {
+            if (_optionalChain([ex, 'access', _332 => _332.response, 'optionalAccess', _333 => _333.status]) === 302 && _optionalChain([ex, 'access', _334 => _334.response, 'access', _335 => _335.headers, 'optionalAccess', _336 => _336.location, 'optionalAccess', _337 => _337.indexOf, 'call', _338 => _338("code=")]) > -1) {
               adminClientId = state2.getAdminClientId() || forgeopsClientId;
               verboseMessage({
                 message: C.cyan(`ForgeOps deployment`) + ` detected.`,
@@ -193459,14 +193510,20 @@ async function determineDeploymentType(state2) {
     }
   }
 }
+var UNKNOWN_AM_VERSION = "0.0.0";
 function getSemanticVersion(versionInfo) {
-  if ("version" in versionInfo) {
-    const versionString = versionInfo.version;
-    const rx = /([\d]\.[\d]\.[\d](\.[\d])*)/g;
-    const version32 = versionString.match(rx);
-    return version32[0];
+  const versionFields = [_optionalChain([versionInfo, 'optionalAccess', _339 => _339.version]), _optionalChain([versionInfo, 'optionalAccess', _340 => _340.fullVersion])];
+  const semanticVersionRegex = /(\d+\.\d+\.\d+(?:\.\d+)*)/;
+  for (const versionField of versionFields) {
+    if (typeof versionField !== "string") {
+      continue;
+    }
+    const version32 = versionField.match(semanticVersionRegex);
+    if (version32) {
+      return version32[0];
+    }
   }
-  throw new Error("Cannot extract semantic version from version info object.");
+  return UNKNOWN_AM_VERSION;
 }
 async function getFreshUserSessionToken({
   stepHandler,
@@ -193673,7 +193730,7 @@ async function getAuthCode(scope, redirectUri, codeChallenge, codeChallengeMetho
         throw error49;
       }
     }
-    const redirectLocationURL = _optionalChain([response, 'access', _334 => _334.headers, 'optionalAccess', _335 => _335.location]);
+    const redirectLocationURL = _optionalChain([response, 'access', _341 => _341.headers, 'optionalAccess', _342 => _342.location]);
     const parsedUrl = new (0, _url2.URL)(redirectLocationURL, state2.getHost());
     const code = parsedUrl.searchParams.get("code");
     if (code) {
@@ -193891,7 +193948,7 @@ async function getPfUserBearerToken(state2) {
 }
 function createPayload(serviceAccountId, host) {
   const u = parseUrl3(host);
-  const aud = `${u.origin}:${u.port ? u.port : u.protocol === "https" ? "443" : "80"}${u.pathname}/oauth2/access_token`;
+  const aud = `${u.origin}${u.port ? "" : `:${u.protocol === "https" ? "443" : "80"}`}${u.pathname.replace(/\/$/, "")}/oauth2/access_token`;
   const exp = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3 + 180);
   const jti = v4_default();
   const iss = serviceAccountId;
@@ -193924,7 +193981,7 @@ async function getFreshSaBearerToken({
     });
   } catch (error49) {
     const err = error49;
-    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _336 => _336.httpDescription, 'optionalAccess', _337 => _337.startsWith, 'call', _338 => _338("Unsupported scope for service account: ")])) {
+    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _343 => _343.httpDescription, 'optionalAccess', _344 => _344.startsWith, 'call', _345 => _345("Unsupported scope for service account: ")])) {
       const invalidScopes = err.httpDescription.substring(39).split(",");
       const finalScopes = scope.split(" ").filter((el) => {
         return !invalidScopes.includes(el);
@@ -193980,7 +194037,7 @@ async function getFreshPfSaBearerToken({
     });
   } catch (error49) {
     const err = error49;
-    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _339 => _339.httpDescription, 'optionalAccess', _340 => _340.startsWith, 'call', _341 => _341("Unsupported scope for service account: ")])) {
+    if (err.isHttpError && err.httpErrorText === "invalid_scope" && _optionalChain([err, 'access', _346 => _346.httpDescription, 'optionalAccess', _347 => _347.startsWith, 'call', _348 => _348("Unsupported scope for service account: ")])) {
       const invalidScopes = err.httpDescription.substring(39).split(",");
       const finalScopes = scope.split(" ").filter((el) => {
         return !invalidScopes.includes(el);
@@ -194163,9 +194220,9 @@ function scheduleAutoRefresh(forceLoginAsUser, autoRefresh, state2) {
     clearTimeout(timer);
   }
   if (autoRefresh) {
-    const expires = state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY ? _optionalChain([state2, 'access', _342 => _342.getUserSessionTokenMeta, 'call', _343 => _343(), 'optionalAccess', _344 => _344.expires]) : state2.getUseBearerTokenForAmApis() ? _optionalChain([state2, 'access', _345 => _345.getBearerTokenMeta, 'call', _346 => _346(), 'optionalAccess', _347 => _347.expires]) : Math.min(
-      _optionalChain([state2, 'access', _348 => _348.getBearerTokenMeta, 'call', _349 => _349(), 'optionalAccess', _350 => _350.expires]),
-      _optionalChain([state2, 'access', _351 => _351.getUserSessionTokenMeta, 'call', _352 => _352(), 'optionalAccess', _353 => _353.expires])
+    const expires = state2.getDeploymentType() === Constants_default.CLASSIC_DEPLOYMENT_TYPE_KEY ? _optionalChain([state2, 'access', _349 => _349.getUserSessionTokenMeta, 'call', _350 => _350(), 'optionalAccess', _351 => _351.expires]) : state2.getUseBearerTokenForAmApis() ? _optionalChain([state2, 'access', _352 => _352.getBearerTokenMeta, 'call', _353 => _353(), 'optionalAccess', _354 => _354.expires]) : Math.min(
+      _optionalChain([state2, 'access', _355 => _355.getBearerTokenMeta, 'call', _356 => _356(), 'optionalAccess', _357 => _357.expires]),
+      _optionalChain([state2, 'access', _358 => _358.getUserSessionTokenMeta, 'call', _359 => _359(), 'optionalAccess', _360 => _360.expires])
     );
     let timeout4 = expires - Date.now() - 1e3 * 25;
     if (timeout4 < 1e3 * 30) {
@@ -194357,10 +194414,10 @@ async function getTokens({
       throw new FrodoError(`Incomplete or no credentials`);
     }
     if (state2.getCookieValue() || state2.getUseBearerTokenForAmApis() && state2.getBearerToken()) {
-      if (_optionalChain([state2, 'access', _354 => _354.getBearerTokenMeta, 'call', _355 => _355(), 'optionalAccess', _356 => _356.from_cache])) {
+      if (_optionalChain([state2, 'access', _361 => _361.getBearerTokenMeta, 'call', _362 => _362(), 'optionalAccess', _363 => _363.from_cache])) {
         verboseMessage({ message: `Using cached bearer token.`, state: state2 });
       }
-      if (!state2.getUseBearerTokenForAmApis() && _optionalChain([state2, 'access', _357 => _357.getUserSessionTokenMeta, 'call', _358 => _358(), 'optionalAccess', _359 => _359.from_cache])) {
+      if (!state2.getUseBearerTokenForAmApis() && _optionalChain([state2, 'access', _364 => _364.getUserSessionTokenMeta, 'call', _365 => _365(), 'optionalAccess', _366 => _366.from_cache])) {
         verboseMessage({ message: `Using cached session token.`, state: state2 });
       }
       scheduleAutoRefresh(forceLoginAsUser, autoRefresh, state2);
@@ -194487,7 +194544,7 @@ async function readAuthenticationSettings({
     const settings = await getAuthenticationSettings({ state: state2, globalConfig: globalConfig2 });
     return settings;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _360 => _360.response, 'optionalAccess', _361 => _361.status]) === 403 && _optionalChain([error49, 'access', _362 => _362.response, 'optionalAccess', _363 => _363.data, 'optionalAccess', _364 => _364.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+    if (_optionalChain([error49, 'access', _367 => _367.response, 'optionalAccess', _368 => _368.status]) === 403 && _optionalChain([error49, 'access', _369 => _369.response, 'optionalAccess', _370 => _370.data, 'optionalAccess', _371 => _371.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
       return null;
     } else {
       throw new FrodoError(
@@ -195009,7 +195066,7 @@ async function importServers({
             state: state2
           });
         } catch (e) {
-          if (_optionalChain([e, 'access', _365 => _365.response, 'optionalAccess', _366 => _366.status]) !== 400 || _optionalChain([e, 'access', _367 => _367.response, 'optionalAccess', _368 => _368.data, 'optionalAccess', _369 => _369.message]) !== "Update not supported") {
+          if (_optionalChain([e, 'access', _372 => _372.response, 'optionalAccess', _373 => _373.status]) !== 400 || _optionalChain([e, 'access', _374 => _374.response, 'optionalAccess', _375 => _375.data, 'optionalAccess', _376 => _376.message]) !== "Update not supported") {
             throw new FrodoError(
               `Error creating server with id '${server._id}' and URL '${server.url}'`,
               e
@@ -195476,7 +195533,7 @@ async function updateAdminFederationProvider({
     });
     return response;
   } catch (importError) {
-    if (_optionalChain([importError, 'access', _370 => _370.response, 'optionalAccess', _371 => _371.status]) === 400 && _optionalChain([importError, 'access', _372 => _372.response, 'optionalAccess', _373 => _373.data, 'optionalAccess', _374 => _374.message]) === "Invalid attribute specified.") {
+    if (_optionalChain([importError, 'access', _377 => _377.response, 'optionalAccess', _378 => _378.status]) === 400 && _optionalChain([importError, 'access', _379 => _379.response, 'optionalAccess', _380 => _380.data, 'optionalAccess', _381 => _381.message]) === "Invalid attribute specified.") {
       const { validAttributes } = importError.response.data.detail;
       validAttributes.push("_id", "_type");
       for (const attribute of Object.keys(providerData)) {
@@ -197977,7 +198034,7 @@ async function importCertificationTemplates({
           state: state2
         });
       } catch (error49) {
-        if (_optionalChain([error49, 'access', _375 => _375.response, 'optionalAccess', _376 => _376.status]) === 404 && _optionalChain([error49, 'access', _377 => _377.response, 'optionalAccess', _378 => _378.data, 'optionalAccess', _379 => _379.message]) && error49.response.data.message.startsWith("Cannot find template with id")) {
+        if (_optionalChain([error49, 'access', _382 => _382.response, 'optionalAccess', _383 => _383.status]) === 404 && _optionalChain([error49, 'access', _384 => _384.response, 'optionalAccess', _385 => _385.data, 'optionalAccess', _386 => _386.message]) && error49.response.data.message.startsWith("Cannot find template with id")) {
           result = await createCertificationTemplate2({
             templateData,
             state: state2
@@ -199052,6 +199109,16 @@ function createSecretsExportTemplate({
     secret: {}
   };
 }
+function warnSkippedActiveValueExport({
+  secretId,
+  state: state2
+}) {
+  printMessage({
+    message: `Warning: Secret '${secretId}' has 'Use in Placeholders' disabled, skipping active value export.`,
+    type: "warn",
+    state: state2
+  });
+}
 async function exportSecret({
   secretId,
   options = { includeActiveValues: false, target: null },
@@ -199063,11 +199130,15 @@ async function exportSecret({
     const exportData = createSecretsExportTemplate({ state: state2 });
     const secret = await readSecret({ secretId, state: state2 });
     if (includeActiveValues) {
-      secret.activeValue = await readSecretValue({
-        secretId: secret._id,
-        target,
-        state: state2
-      });
+      if (secret.useInPlaceholders) {
+        secret.activeValue = await readSecretValue({
+          secretId: secret._id,
+          target,
+          state: state2
+        });
+      } else {
+        warnSkippedActiveValueExport({ secretId: secret._id, state: state2 });
+      }
     }
     exportData.secret[secret._id] = secret;
     debugMessage({ message: `SecretsOps.exportSecret: end`, state: state2 });
@@ -199103,7 +199174,11 @@ async function exportSecrets({
           message: `Exporting secret ${secret._id}`,
           state: state2
         });
-        secret.activeValue = mapOfSecrets[secret._id];
+        if (secret.useInPlaceholders) {
+          secret.activeValue = mapOfSecrets[secret._id];
+        } else {
+          warnSkippedActiveValueExport({ secretId: secret._id, state: state2 });
+        }
         exportData.secret[secret._id] = secret;
       }
     } else {
@@ -199733,9 +199808,21 @@ var StartupOps_default = (state2) => {
         timeout: timeout4,
         state: state2
       });
+    },
+    /**
+     * Get the current restart status of the environment
+     * @returns {Promise<RestartStatus>} the current restart status
+     */
+    async readStatus() {
+      return readStatus({ state: state2 });
     }
   };
 };
+async function readStatus({
+  state: state2
+}) {
+  return getStatus({ state: state2 });
+}
 async function checkForUpdates({
   state: state2
 }) {
@@ -199761,7 +199848,7 @@ async function checkForUpdates({
       state: state2
     });
   }
-  const updateCount = _optionalChain([updates, 'access', _380 => _380.secrets, 'optionalAccess', _381 => _381.length]) + _optionalChain([updates, 'access', _382 => _382.variables, 'optionalAccess', _383 => _383.length]) || 0;
+  const updateCount = _optionalChain([updates, 'access', _387 => _387.secrets, 'optionalAccess', _388 => _388.length]) + _optionalChain([updates, 'access', _389 => _389.variables, 'optionalAccess', _390 => _390.length]) || 0;
   if (updateCount > 0) {
     stopProgressIndicator({
       id: indicatorId,
@@ -199854,7 +199941,7 @@ async function applyUpdates({
   } catch (error49) {
     stopProgressIndicator({
       id: indicatorId,
-      message: `Error: ${_optionalChain([error49, 'access', _384 => _384.response, 'optionalAccess', _385 => _385.data, 'optionalAccess', _386 => _386.code]) || error49} - ${_optionalChain([error49, 'access', _387 => _387.response, 'optionalAccess', _388 => _388.data, 'optionalAccess', _389 => _389.message])}`,
+      message: `Error: ${_optionalChain([error49, 'access', _391 => _391.response, 'optionalAccess', _392 => _392.data, 'optionalAccess', _393 => _393.code]) || error49} - ${_optionalChain([error49, 'access', _394 => _394.response, 'optionalAccess', _395 => _395.data, 'optionalAccess', _396 => _396.message])}`,
       status: "fail",
       state: state2
     });
@@ -200982,8 +201069,8 @@ async function readSocialIdentityProviders({
   } catch (error49) {
     if (
       // service accounts don't have access to social idps in root realm in AIC
-      state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY && _optionalChain([error49, 'access', _390 => _390.response, 'optionalAccess', _391 => _391.status]) === 403 && state2.getUseBearerTokenForAmApis() && getCurrentRealmName(state2) === "/" || // hm... not sure if this clause ever tiggers
-      _optionalChain([error49, 'access', _392 => _392.response, 'optionalAccess', _393 => _393.status]) === 403 && _optionalChain([error49, 'access', _394 => _394.response, 'optionalAccess', _395 => _395.data, 'optionalAccess', _396 => _396.message]) === "This operation is not available in PingOne Advanced Identity Cloud."
+      state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY && _optionalChain([error49, 'access', _397 => _397.response, 'optionalAccess', _398 => _398.status]) === 403 && state2.getUseBearerTokenForAmApis() && getCurrentRealmName(state2) === "/" || // hm... not sure if this clause ever tiggers
+      _optionalChain([error49, 'access', _399 => _399.response, 'optionalAccess', _400 => _400.status]) === 403 && _optionalChain([error49, 'access', _401 => _401.response, 'optionalAccess', _402 => _402.data, 'optionalAccess', _403 => _403.message]) === "This operation is not available in PingOne Advanced Identity Cloud."
     ) {
       return [];
     } else {
@@ -201082,7 +201169,7 @@ async function updateSocialIdentityProvider({
     });
     return response;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _397 => _397.response, 'optionalAccess', _398 => _398.status]) === 500 && _optionalChain([error49, 'access', _399 => _399.response, 'optionalAccess', _400 => _400.data, 'optionalAccess', _401 => _401.message]) === "Unable to update SMS config: Data validation failed for the attribute, Redirect after form post URL") {
+    if (_optionalChain([error49, 'access', _404 => _404.response, 'optionalAccess', _405 => _405.status]) === 500 && _optionalChain([error49, 'access', _406 => _406.response, 'optionalAccess', _407 => _407.data, 'optionalAccess', _408 => _408.message]) === "Unable to update SMS config: Data validation failed for the attribute, Redirect after form post URL") {
       providerData["redirectAfterFormPostURI"] = "";
       try {
         await putProviderByTypeAndId2({
@@ -201094,7 +201181,7 @@ async function updateSocialIdentityProvider({
       } catch (importError2) {
         throw new FrodoError(`Error updating provider ${providerId}`, error49);
       }
-    } else if (_optionalChain([error49, 'access', _402 => _402.response, 'optionalAccess', _403 => _403.status]) === 400 && _optionalChain([error49, 'access', _404 => _404.response, 'optionalAccess', _405 => _405.data, 'optionalAccess', _406 => _406.message]) === "Invalid attribute specified.") {
+    } else if (_optionalChain([error49, 'access', _409 => _409.response, 'optionalAccess', _410 => _410.status]) === 400 && _optionalChain([error49, 'access', _411 => _411.response, 'optionalAccess', _412 => _412.data, 'optionalAccess', _413 => _413.message]) === "Invalid attribute specified.") {
       const { validAttributes } = error49.response.data.detail;
       for (const attribute of Object.keys(providerData)) {
         if (!validAttributes.includes(attribute)) {
@@ -202106,13 +202193,13 @@ async function getTreesCount({
   }).get(urlString, {
     withCredentials: true
   });
-  if (typeof _optionalChain([data2, 'optionalAccess', _407 => _407.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _414 => _414.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
     return data2.totalPagedResults;
   }
-  if (typeof _optionalChain([data2, 'optionalAccess', _408 => _408.resultCount]) === "number" && data2.resultCount >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _415 => _415.resultCount]) === "number" && data2.resultCount >= 0) {
     return data2.resultCount;
   }
-  return Array.isArray(_optionalChain([data2, 'optionalAccess', _409 => _409.result])) ? data2.result.length : 0;
+  return Array.isArray(_optionalChain([data2, 'optionalAccess', _416 => _416.result])) ? data2.result.length : 0;
 }
 async function getTree({ id: id7, state: state2 }) {
   const urlString = _util2.default.format(
@@ -203028,7 +203115,7 @@ async function updateCustomNode({
     }
     result = await putCustomNode({ nodeId, nodeData, state: state2 });
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _410 => _410.response, 'optionalAccess', _411 => _411.status]) === 409 && _optionalChain([error49, 'access', _412 => _412.response, 'optionalAccess', _413 => _413.data, 'access', _414 => _414.message, 'access', _415 => _415.startsWith, 'call', _416 => _416("Node Type with display name")]) && _optionalChain([error49, 'access', _417 => _417.response, 'optionalAccess', _418 => _418.data, 'access', _419 => _419.message, 'access', _420 => _420.endsWith, 'call', _421 => _421("already exists")])) {
+    if (_optionalChain([error49, 'access', _417 => _417.response, 'optionalAccess', _418 => _418.status]) === 409 && _optionalChain([error49, 'access', _419 => _419.response, 'optionalAccess', _420 => _420.data, 'access', _421 => _421.message, 'access', _422 => _422.startsWith, 'call', _423 => _423("Node Type with display name")]) && _optionalChain([error49, 'access', _424 => _424.response, 'optionalAccess', _425 => _425.data, 'access', _426 => _426.message, 'access', _427 => _427.endsWith, 'call', _428 => _428("already exists")])) {
       verboseMessage({
         message: `updateCustomNode WARNING: custom node with display name ${nodeData.displayName} already exists, using renaming policy... <name> => <name - imported (n)>`,
         state: state2
@@ -203089,7 +203176,7 @@ async function importCustomNodes({
           message: `NodeOps.importCustomNodes: Custom node ${nodeData.displayName} (${existingId}) already exists, attempting to update...`,
           state: state2
         });
-        if (_optionalChain([error49, 'access', _422 => _422.response, 'optionalAccess', _423 => _423.status]) === 409) {
+        if (_optionalChain([error49, 'access', _429 => _429.response, 'optionalAccess', _430 => _430.status]) === 409) {
           result = await updateCustomNode({
             nodeId: newId,
             nodeData,
@@ -204423,6 +204510,38 @@ function hasScriptDependency(nodeConfig) {
 }
 var emailTemplateNodes = ["EmailSuspendNode", "EmailTemplateNode"];
 var emptyScriptPlaceholder = "[Empty]";
+var treeDependencyNodeTypes = /* @__PURE__ */ new Set([
+  "InnerTreeEvaluatorNode",
+  "BackChannelInitNode"
+]);
+function getTreeDependencyId({
+  nodeType,
+  nodeConfig
+}) {
+  const dependencyNodeType = _nullishCoalesce(nodeType, () => ( _optionalChain([nodeConfig, 'optionalAccess', _431 => _431._type, 'optionalAccess', _432 => _432._id])));
+  if (!dependencyNodeType || !treeDependencyNodeTypes.has(dependencyNodeType) || typeof _optionalChain([nodeConfig, 'optionalAccess', _433 => _433.tree]) !== "string") {
+    return void 0;
+  }
+  return nodeConfig.tree;
+}
+function collectTreeDependencyIds(treeDependencyMap, treeIds = []) {
+  for (const [treeId, dependencies] of Object.entries(treeDependencyMap)) {
+    for (const dependencyMap of dependencies) {
+      collectTreeDependencyIds(dependencyMap, treeIds);
+    }
+    if (!treeIds.includes(treeId)) {
+      treeIds.push(treeId);
+    }
+  }
+  return treeIds;
+}
+function stripExportMetadata(exportData) {
+  const treeExport = {
+    ...exportData
+  };
+  delete treeExport.meta;
+  return treeExport;
+}
 function createSingleTreeExportTemplate({
   state: state2
 }) {
@@ -204513,7 +204632,7 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
         }
         saml2EntityPromises.push(providerResponse);
       } catch (error49) {
-        error49.message = `Error reading ${getCurrentRealmName(state2) + " realm"} saml2 dependencies: ${_optionalChain([error49, 'access', _424 => _424.response, 'optionalAccess', _425 => _425.data, 'optionalAccess', _426 => _426.message]) || error49.message}`;
+        error49.message = `Error reading ${getCurrentRealmName(state2) + " realm"} saml2 dependencies: ${_optionalChain([error49, 'access', _434 => _434.response, 'optionalAccess', _435 => _435.data, 'optionalAccess', _436 => _436.message]) || error49.message}`;
         errors.push(error49);
       }
     }
@@ -204542,7 +204661,7 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
       circlesOfTrust
     };
   } catch (error49) {
-    error49.message = `Error reading ${getCurrentRealmName(state2) + " realm"} saml2 dependencies: ${_optionalChain([error49, 'access', _427 => _427.response, 'optionalAccess', _428 => _428.data, 'optionalAccess', _429 => _429.message]) || error49.message}`;
+    error49.message = `Error reading ${getCurrentRealmName(state2) + " realm"} saml2 dependencies: ${_optionalChain([error49, 'access', _437 => _437.response, 'optionalAccess', _438 => _438.data, 'optionalAccess', _439 => _439.message]) || error49.message}`;
     errors.push(error49);
   }
   if (errors.length) {
@@ -204554,7 +204673,7 @@ ${errorMessages}`
   }
   return saml2NodeDependencies;
 }
-async function exportJourney({
+async function exportSingleJourney({
   journeyId,
   options = {
     useStringArrays: true,
@@ -204653,7 +204772,7 @@ async function exportJourney({
       if (deps && hasScriptDependency(nodeObject) && nodeObject.script !== emptyScriptPlaceholder) {
         scriptPromises.push(readScript({ scriptId: nodeObject.script, state: state2 }));
       }
-      if (deps && _optionalChain([nodeObject, 'access', _430 => _430._type, 'optionalAccess', _431 => _431._id]) && nodeObject._type._id.startsWith("designer-")) {
+      if (deps && _optionalChain([nodeObject, 'access', _440 => _440._type, 'optionalAccess', _441 => _441._id]) && nodeObject._type._id.startsWith("designer-")) {
         customNodePromises.push(
           readCustomNode({
             nodeId: nodeObject._type._id.substring(9) + "-1",
@@ -204674,7 +204793,7 @@ async function exportJourney({
             });
             emailTemplatePromises.push(emailTemplate);
           } catch (error49) {
-            error49.message = `Error reading email template ${nodeObject.emailTemplateName}: ${_optionalChain([error49, 'access', _432 => _432.response, 'optionalAccess', _433 => _433.data, 'optionalAccess', _434 => _434.message]) || error49.message}`;
+            error49.message = `Error reading email template ${nodeObject.emailTemplateName}: ${_optionalChain([error49, 'access', _442 => _442.response, 'optionalAccess', _443 => _443.data, 'optionalAccess', _444 => _444.message]) || error49.message}`;
             errors.push(error49);
           }
         }
@@ -204776,7 +204895,7 @@ async function exportJourney({
               readScript({ scriptId: innerNodeObject.script, state: state2 })
             );
           }
-          if (deps && _optionalChain([innerNodeObject, 'access', _435 => _435._type, 'optionalAccess', _436 => _436._id]) && innerNodeObject._type._id.startsWith("designer-")) {
+          if (deps && _optionalChain([innerNodeObject, 'access', _445 => _445._type, 'optionalAccess', _446 => _446._id]) && innerNodeObject._type._id.startsWith("designer-")) {
             customNodePromises.push(
               readCustomNode({
                 nodeId: innerNodeObject._type._id.substring(9) + "-1",
@@ -205052,7 +205171,7 @@ async function exportJourney({
         for (const themeObject of themePromiseResults) {
           if (themeObject && // has the theme been specified by id or name in a page node?
           (themes.includes(themeObject._id) || themes.includes(themeObject.name) || // has this journey been linked to a theme?
-          _optionalChain([themeObject, 'access', _437 => _437.linkedTrees, 'optionalAccess', _438 => _438.includes, 'call', _439 => _439(treeObject._id)]))) {
+          _optionalChain([themeObject, 'access', _447 => _447.linkedTrees, 'optionalAccess', _448 => _448.includes, 'call', _449 => _449(treeObject._id)]))) {
             if (verbose)
               printMessage({
                 message: `
@@ -205091,6 +205210,43 @@ async function exportJourney({
   });
   return exportData;
 }
+async function exportJourney({
+  journeyId,
+  options = {
+    useStringArrays: true,
+    deps: true,
+    coords: true
+  },
+  resolveTreeExport = onlineTreeExportResolver,
+  state: state2
+}) {
+  const exportData = await exportSingleJourney({ journeyId, options, state: state2 });
+  if (!options.deps) {
+    const multiTreeExport2 = createMultiTreeExportTemplate({ state: state2 });
+    multiTreeExport2.trees[journeyId] = stripExportMetadata(exportData);
+    return multiTreeExport2;
+  }
+  const treeDependencyMap = await getTreeDescendents({
+    treeExport: exportData,
+    resolveTreeExport,
+    resolvedTreeIds: [],
+    state: state2
+  });
+  const dependencyTreeIds = collectTreeDependencyIds(treeDependencyMap).filter(
+    (treeId) => treeId !== journeyId
+  );
+  const multiTreeExport = createMultiTreeExportTemplate({ state: state2 });
+  for (const dependencyTreeId of dependencyTreeIds) {
+    const dependencyExport = resolveTreeExport === onlineTreeExportResolver ? await exportSingleJourney({
+      journeyId: dependencyTreeId,
+      options,
+      state: state2
+    }) : await resolveTreeExport(dependencyTreeId, state2);
+    multiTreeExport.trees[dependencyTreeId] = stripExportMetadata(dependencyExport);
+  }
+  multiTreeExport.trees[journeyId] = stripExportMetadata(exportData);
+  return multiTreeExport;
+}
 async function exportJourneys({
   options = {
     useStringArrays: true,
@@ -205111,7 +205267,7 @@ async function exportJourneys({
     const exportData = await getResult(
       resultCallback,
       `Error exporting the ${getCurrentRealmName(state2) + " realm"} journey ${tree._id}`,
-      exportJourney,
+      exportSingleJourney,
       {
         journeyId: tree._id,
         options,
@@ -205514,7 +205670,7 @@ async function importJourney({
         try {
           await createCircleOfTrust({ cotData, state: state2 });
         } catch (error49) {
-          if (_optionalChain([error49, 'access', _440 => _440.response, 'optionalAccess', _441 => _441.status]) === 409 || _optionalChain([error49, 'access', _442 => _442.response, 'optionalAccess', _443 => _443.status]) === 500) {
+          if (_optionalChain([error49, 'access', _450 => _450.response, 'optionalAccess', _451 => _451.status]) === 409 || _optionalChain([error49, 'access', _452 => _452.response, 'optionalAccess', _453 => _453.status]) === 500) {
             try {
               await updateCircleOfTrust({ cotId, cotData, state: state2 });
             } catch (updateCotErr) {
@@ -205600,17 +205756,17 @@ async function importJourney({
           await updateNode({
             nodeId: newUuid,
             nodeType,
-            nodeTypeVersion: _optionalChain([innerNodeData, 'access', _444 => _444["_type"], 'optionalAccess', _445 => _445["version"]]) || "1.0",
+            nodeTypeVersion: _optionalChain([innerNodeData, 'access', _454 => _454["_type"], 'optionalAccess', _455 => _455["version"]]) || "1.0",
             nodeData: innerNodeData,
             state: state2
           });
         } catch (nodeImportError) {
-          if (_optionalChain([nodeImportError, 'access', _446 => _446.response, 'optionalAccess', _447 => _447.status]) === 400 && _optionalChain([nodeImportError, 'access', _448 => _448.response, 'optionalAccess', _449 => _449.data, 'optionalAccess', _450 => _450.message]) === "Data validation failed for the attribute, Script") {
+          if (_optionalChain([nodeImportError, 'access', _456 => _456.response, 'optionalAccess', _457 => _457.status]) === 400 && _optionalChain([nodeImportError, 'access', _458 => _458.response, 'optionalAccess', _459 => _459.data, 'optionalAccess', _460 => _460.message]) === "Data validation failed for the attribute, Script") {
             throw new FrodoError(
               `Missing ${getCurrentRealmName(state2) + " realm"} script ${innerNodeData["script"]} referenced by inner node ${innerNodeId}${innerNodeId === newUuid ? "" : ` [${newUuid}]`} (${innerNodeData["_type"]["_id"]}) in journey ${treeId}`,
               nodeImportError
             );
-          } else if (_optionalChain([nodeImportError, 'access', _451 => _451.response, 'optionalAccess', _452 => _452.status]) === 400 && _optionalChain([nodeImportError, 'access', _453 => _453.response, 'optionalAccess', _454 => _454.data, 'optionalAccess', _455 => _455.message]) === "Invalid attribute specified.") {
+          } else if (_optionalChain([nodeImportError, 'access', _461 => _461.response, 'optionalAccess', _462 => _462.status]) === 400 && _optionalChain([nodeImportError, 'access', _463 => _463.response, 'optionalAccess', _464 => _464.data, 'optionalAccess', _465 => _465.message]) === "Invalid attribute specified.") {
             const { validAttributes } = nodeImportError.response.data.detail;
             validAttributes.push("_id");
             for (const attribute of Object.keys(innerNodeData)) {
@@ -205630,7 +205786,7 @@ async function importJourney({
               await updateNode({
                 nodeId: newUuid,
                 nodeType,
-                nodeTypeVersion: _optionalChain([innerNodeData, 'access', _456 => _456["_type"], 'optionalAccess', _457 => _457["version"]]) || "1.0",
+                nodeTypeVersion: _optionalChain([innerNodeData, 'access', _466 => _466["_type"], 'optionalAccess', _467 => _467["version"]]) || "1.0",
                 nodeData: innerNodeData,
                 state: state2
               });
@@ -205640,7 +205796,7 @@ async function importJourney({
                 nodeImportError2
               );
             }
-          } else if (_optionalChain([nodeImportError, 'access', _458 => _458.response, 'optionalAccess', _459 => _459.status]) === 404) {
+          } else if (_optionalChain([nodeImportError, 'access', _468 => _468.response, 'optionalAccess', _469 => _469.status]) === 404) {
             throw new FrodoError(
               `Unable to import ${getCurrentRealmName(state2) + " realm"} node ${innerNodeId}${innerNodeId === newUuid ? "" : ` [${newUuid}]`} in journey ${treeId} because its type ${innerNodeData._type._id} doesn't exist in deployment`,
               nodeImportError
@@ -205661,7 +205817,7 @@ async function importJourney({
       for (let [nodeId, nodeData] of Object.entries(importData.nodes)) {
         delete nodeData["_rev"];
         const nodeType = nodeData["_type"]["_id"];
-        const nodeTypeVersion = _optionalChain([nodeData, 'access', _460 => _460["_type"], 'optionalAccess', _461 => _461["version"]]) || "1.0";
+        const nodeTypeVersion = _optionalChain([nodeData, 'access', _470 => _470["_type"], 'optionalAccess', _471 => _471["version"]]) || "1.0";
         if (!reUuid) {
           newUuid = nodeId;
         } else {
@@ -205722,12 +205878,12 @@ async function importJourney({
             state: state2
           });
         } catch (nodeImportError) {
-          if (_optionalChain([nodeImportError, 'access', _462 => _462.response, 'optionalAccess', _463 => _463.status]) === 400 && _optionalChain([nodeImportError, 'access', _464 => _464.response, 'optionalAccess', _465 => _465.data, 'optionalAccess', _466 => _466.message]) === "Data validation failed for the attribute, Script") {
+          if (_optionalChain([nodeImportError, 'access', _472 => _472.response, 'optionalAccess', _473 => _473.status]) === 400 && _optionalChain([nodeImportError, 'access', _474 => _474.response, 'optionalAccess', _475 => _475.data, 'optionalAccess', _476 => _476.message]) === "Data validation failed for the attribute, Script") {
             throw new FrodoError(
               `Missing ${getCurrentRealmName(state2) + " realm"} script ${nodeData["script"]} referenced by node ${nodeId}${nodeId === newUuid ? "" : ` [${newUuid}]`} (${nodeData["_type"]["_id"]}) in journey ${treeId}`,
               nodeImportError
             );
-          } else if (_optionalChain([nodeImportError, 'access', _467 => _467.response, 'optionalAccess', _468 => _468.status]) === 400 && _optionalChain([nodeImportError, 'access', _469 => _469.response, 'optionalAccess', _470 => _470.data, 'optionalAccess', _471 => _471.message]) === "Invalid attribute specified.") {
+          } else if (_optionalChain([nodeImportError, 'access', _477 => _477.response, 'optionalAccess', _478 => _478.status]) === 400 && _optionalChain([nodeImportError, 'access', _479 => _479.response, 'optionalAccess', _480 => _480.data, 'optionalAccess', _481 => _481.message]) === "Invalid attribute specified.") {
             const { validAttributes } = nodeImportError.response.data.detail;
             validAttributes.push("_id");
             for (const attribute of Object.keys(nodeData)) {
@@ -205757,7 +205913,7 @@ async function importJourney({
                 nodeImportError2
               );
             }
-          } else if (_optionalChain([nodeImportError, 'access', _472 => _472.response, 'optionalAccess', _473 => _473.status]) === 404) {
+          } else if (_optionalChain([nodeImportError, 'access', _482 => _482.response, 'optionalAccess', _483 => _483.status]) === 404) {
             throw new FrodoError(
               `Unable to import ${getCurrentRealmName(state2) + " realm"} node ${nodeId}${nodeId === newUuid ? "" : ` [${newUuid}]`} in journey ${treeId} because its type ${nodeData._type._id} doesn't exist in deployment`,
               nodeImportError
@@ -205821,7 +205977,7 @@ async function importJourney({
           state: state2
         });
     } catch (importError) {
-      if (_optionalChain([importError, 'access', _474 => _474.response, 'optionalAccess', _475 => _475.status]) === 400 && _optionalChain([importError, 'access', _476 => _476.response, 'optionalAccess', _477 => _477.data, 'optionalAccess', _478 => _478.message]) === "Invalid attribute specified.") {
+      if (_optionalChain([importError, 'access', _484 => _484.response, 'optionalAccess', _485 => _485.status]) === 400 && _optionalChain([importError, 'access', _486 => _486.response, 'optionalAccess', _487 => _487.data, 'optionalAccess', _488 => _488.message]) === "Invalid attribute specified.") {
         const { validAttributes } = importError.response.data.detail;
         validAttributes.push("_id");
         for (const attribute of Object.keys(importData.tree)) {
@@ -205889,8 +206045,11 @@ async function resolveDependencies(installedJorneys, journeyMap, unresolvedJourn
     if ({}.hasOwnProperty.call(journeyMap, tree)) {
       const dependencies = [];
       for (const node2 in journeyMap[tree].nodes) {
-        if (journeyMap[tree].nodes[node2]._type._id === "InnerTreeEvaluatorNode") {
-          dependencies.push(journeyMap[tree].nodes[node2].tree);
+        const dependency = getTreeDependencyId({
+          nodeConfig: journeyMap[tree].nodes[node2]
+        });
+        if (dependency) {
+          dependencies.push(dependency);
         }
       }
       let allResolved = true;
@@ -206009,7 +206168,7 @@ function getNodeRef(nodeObj, singleTreeExport) {
 }
 var onlineTreeExportResolver = async function(treeId, state2) {
   debugMessage({ message: `onlineTreeExportResolver(${treeId})`, state: state2 });
-  return await exportJourney({
+  return await exportSingleJourney({
     journeyId: treeId,
     options: {
       deps: false,
@@ -206030,7 +206189,7 @@ var fileByIdTreeExportResolver = async function(treeId, state2) {
       message: `fileByIdTreeExportResolver: resolved '${treeId}' to ${file2}`,
       state: state2
     });
-    if (_optionalChain([jsonData, 'access', _479 => _479.tree, 'optionalAccess', _480 => _480._id]) === treeId) {
+    if (_optionalChain([jsonData, 'access', _489 => _489.tree, 'optionalAccess', _490 => _490._id]) === treeId) {
       treeExport = jsonData;
     } else if (jsonData.trees && jsonData.trees[treeId]) {
       treeExport = jsonData.trees[treeId];
@@ -206049,7 +206208,7 @@ function createFileParamTreeExportResolver(file2, state2) {
     let treeExport = createSingleTreeExportTemplate({ state: state2 });
     try {
       const jsonData = JSON.parse(fs52.default.readFileSync(file2, "utf8"));
-      if (_optionalChain([jsonData, 'access', _481 => _481.tree, 'optionalAccess', _482 => _482._id]) === treeId) {
+      if (_optionalChain([jsonData, 'access', _491 => _491.tree, 'optionalAccess', _492 => _492._id]) === treeId) {
         treeExport = jsonData;
       } else if (jsonData.trees && jsonData.trees[treeId]) {
         treeExport = jsonData.trees[treeId];
@@ -206085,23 +206244,24 @@ async function getTreeDescendents({
   for (const [nodeId, node2] of Object.entries(treeExport.tree.nodes)) {
     let innerTreeId;
     try {
-      if (node2.nodeType === "InnerTreeEvaluatorNode") {
-        innerTreeId = treeExport.nodes[nodeId].tree;
-        if (!resolvedTreeIds.includes(innerTreeId)) {
-          const innerTreeExport = await resolveTreeExport(innerTreeId, state2);
-          debugMessage({
-            message: `resolved inner tree: ${innerTreeExport.tree._id}`,
+      innerTreeId = getTreeDependencyId({
+        nodeType: node2.nodeType,
+        nodeConfig: treeExport.nodes[nodeId]
+      });
+      if (innerTreeId && !resolvedTreeIds.includes(innerTreeId)) {
+        const innerTreeExport = await resolveTreeExport(innerTreeId, state2);
+        debugMessage({
+          message: `resolved inner tree: ${innerTreeExport.tree._id}`,
+          state: state2
+        });
+        dependencies.push(
+          await getTreeDescendents({
+            treeExport: innerTreeExport,
+            resolveTreeExport,
+            resolvedTreeIds,
             state: state2
-          });
-          dependencies.push(
-            await getTreeDescendents({
-              treeExport: innerTreeExport,
-              resolveTreeExport,
-              resolvedTreeIds,
-              state: state2
-            })
-          );
-        }
+          })
+        );
       }
     } catch (error49) {
       if (innerTreeId) {
@@ -206119,7 +206279,7 @@ function isConnectedNodeDeleteError(error49) {
   if (error49 instanceof FrodoError && error49.getOriginalErrors().length > 0) {
     return isConnectedNodeDeleteError(error49.getOriginalErrors()[0]);
   }
-  return axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _483 => _483.response, 'optionalAccess', _484 => _484.status]) === 400 && _optionalChain([error49, 'access', _485 => _485.response, 'optionalAccess', _486 => _486.data, 'optionalAccess', _487 => _487.message]) === "Cannot delete a node that is connected in a tree.";
+  return axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _493 => _493.response, 'optionalAccess', _494 => _494.status]) === 400 && _optionalChain([error49, 'access', _495 => _495.response, 'optionalAccess', _496 => _496.data, 'optionalAccess', _497 => _497.message]) === "Cannot delete a node that is connected in a tree.";
 }
 async function deleteJourney({
   journeyId,
@@ -206153,7 +206313,7 @@ async function deleteJourney({
         `Delete endpoint returned success but ${getCurrentRealmName(state2) + " realm"} journey ${journeyId} still exists`
       );
     } catch (error49) {
-      if (!(axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _488 => _488.response, 'optionalAccess', _489 => _489.status]) === 404) && !(error49 instanceof FrodoError)) {
+      if (!(axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _498 => _498.response, 'optionalAccess', _499 => _499.status]) === 404) && !(error49 instanceof FrodoError)) {
         throw error49;
       }
       if (error49 instanceof FrodoError) {
@@ -206246,7 +206406,7 @@ async function deleteJourney({
                       state: state2
                     });
                 } catch (error49) {
-                  if (axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _490 => _490.response, 'optionalAccess', _491 => _491.data, 'optionalAccess', _492 => _492.code]) === 500 && error49.response.data.message === "Unable to read SMS config: Node did not exist") {
+                  if (axios_default.isAxiosError(error49) && _optionalChain([error49, 'access', _500 => _500.response, 'optionalAccess', _501 => _501.data, 'optionalAccess', _502 => _502.code]) === 500 && error49.response.data.message === "Unable to read SMS config: Node did not exist") {
                     status.nodes[containerNode._id] = { status: "success" };
                     if (verbose)
                       printMessage({
@@ -207057,7 +207217,7 @@ async function exportResourceType({
     debugMessage({ message: `ResourceTypeOps.exportResourceType: end`, state: state2 });
     return exportData;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _493 => _493.response, 'optionalAccess', _494 => _494.status]) === 404) {
+    if (_optionalChain([error49, 'access', _503 => _503.response, 'optionalAccess', _504 => _504.status]) === 404) {
       throw new FrodoError(
         `${getCurrentRealmName(state2) + " realm"} resource type ${resourceTypeUuid} does not exist`,
         error49
@@ -207154,7 +207314,7 @@ async function importResourceType({
         try {
           response = await createResourceType({ resourceTypeData, state: state2 });
         } catch (createError) {
-          if (_optionalChain([createError, 'access', _495 => _495.response, 'optionalAccess', _496 => _496.status]) === 409)
+          if (_optionalChain([createError, 'access', _505 => _505.response, 'optionalAccess', _506 => _506.status]) === 409)
             response = await putResourceType({
               resourceTypeUuid: id7,
               resourceTypeData,
@@ -207197,7 +207357,7 @@ async function importResourceTypeByName({
         try {
           response = await createResourceType({ resourceTypeData, state: state2 });
         } catch (createError) {
-          if (_optionalChain([createError, 'access', _497 => _497.response, 'optionalAccess', _498 => _498.status]) === 409)
+          if (_optionalChain([createError, 'access', _507 => _507.response, 'optionalAccess', _508 => _508.status]) === 409)
             response = await putResourceType({
               resourceTypeUuid: id7,
               resourceTypeData,
@@ -207239,7 +207399,7 @@ async function importFirstResourceType({
       try {
         response = await createResourceType({ resourceTypeData, state: state2 });
       } catch (createError) {
-        if (_optionalChain([createError, 'access', _499 => _499.response, 'optionalAccess', _500 => _500.status]) === 409)
+        if (_optionalChain([createError, 'access', _509 => _509.response, 'optionalAccess', _510 => _510.status]) === 409)
           response = await putResourceType({
             resourceTypeUuid: id7,
             resourceTypeData,
@@ -207277,7 +207437,7 @@ async function importResourceTypes({
       try {
         response.push(await createResourceType({ resourceTypeData, state: state2 }));
       } catch (createError) {
-        if (_optionalChain([createError, 'access', _501 => _501.response, 'optionalAccess', _502 => _502.status]) === 409)
+        if (_optionalChain([createError, 'access', _511 => _511.response, 'optionalAccess', _512 => _512.status]) === 409)
           response.push(
             await putResourceType({
               resourceTypeUuid: id7,
@@ -207832,7 +207992,7 @@ async function importPolicySet({
           response = await createPolicySet({ policySetData, state: state2 });
           imported.push(id7);
         } catch (error49) {
-          if (_optionalChain([error49, 'access', _503 => _503.response, 'optionalAccess', _504 => _504.status]) === 409) {
+          if (_optionalChain([error49, 'access', _513 => _513.response, 'optionalAccess', _514 => _514.status]) === 409) {
             response = await updatePolicySet({ policySetData, state: state2 });
             imported.push(id7);
           } else throw error49;
@@ -207894,7 +208054,7 @@ async function importFirstPolicySet({
         response = await createPolicySet({ policySetData, state: state2 });
         imported.push(id7);
       } catch (error49) {
-        if (_optionalChain([error49, 'access', _505 => _505.response, 'optionalAccess', _506 => _506.status]) === 409) {
+        if (_optionalChain([error49, 'access', _515 => _515.response, 'optionalAccess', _516 => _516.status]) === 409) {
           response = await updatePolicySet({ policySetData, state: state2 });
           imported.push(id7);
         } else throw error49;
@@ -207951,7 +208111,7 @@ async function importPolicySets({
       try {
         response.push(await createPolicySet({ policySetData, state: state2 }));
       } catch (error49) {
-        if (_optionalChain([error49, 'access', _507 => _507.response, 'optionalAccess', _508 => _508.status]) === 409) {
+        if (_optionalChain([error49, 'access', _517 => _517.response, 'optionalAccess', _518 => _518.status]) === 409) {
           response.push(await updatePolicySet({ policySetData, state: state2 }));
         } else throw error49;
       }
@@ -209080,7 +209240,7 @@ async function exportScriptTypes({
           state: state2
         });
       } catch (e) {
-        if (e.httpStatus === 404 || _optionalChain([e, 'access', _509 => _509.response, 'optionalAccess', _510 => _510.status]) === 404) {
+        if (e.httpStatus === 404 || _optionalChain([e, 'access', _519 => _519.response, 'optionalAccess', _520 => _520.status]) === 404) {
         } else {
           printMessage({
             message: `Unable to get engine configuration for script type '${scriptType._id}': ${e.message}`,
@@ -209655,7 +209815,7 @@ async function readSecretStores({
           })
         );
       } catch (e) {
-        if (_optionalChain([e, 'access', _511 => _511.response, 'optionalAccess', _512 => _512.status]) === 403 && _optionalChain([e, 'access', _513 => _513.response, 'optionalAccess', _514 => _514.data, 'optionalAccess', _515 => _515.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+        if (_optionalChain([e, 'access', _521 => _521.response, 'optionalAccess', _522 => _522.status]) === 403 && _optionalChain([e, 'access', _523 => _523.response, 'optionalAccess', _524 => _524.data, 'optionalAccess', _525 => _525.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
           return result;
         }
         throw e;
@@ -209881,7 +210041,7 @@ async function importSecretStores({
         continue;
       }
       if (secretStoreId && !secretStoreTypeId)
-        secretStoreTypeId = _optionalChain([secretStore, 'access', _516 => _516._type, 'optionalAccess', _517 => _517._id]) || (await findSecretStore({ secretStoreId, globalConfig: globalConfig2, state: state2 }))._type._id;
+        secretStoreTypeId = _optionalChain([secretStore, 'access', _526 => _526._type, 'optionalAccess', _527 => _527._id]) || (await findSecretStore({ secretStoreId, globalConfig: globalConfig2, state: state2 }))._type._id;
       const isCloudDeployment = state2.getDeploymentType() === Constants_default.CLOUD_DEPLOYMENT_TYPE_KEY;
       let result = secretStore;
       const secretStoreMappings = secretStore.mappings;
@@ -210366,7 +210526,7 @@ async function getListOfServices2({
     debugMessage({ message: `ServiceOps.getListOfServices: end`, state: state2 });
     return services;
   } catch (error49) {
-    if (_optionalChain([error49, 'access', _518 => _518.response, 'optionalAccess', _519 => _519.status]) === 403 && _optionalChain([error49, 'access', _520 => _520.response, 'optionalAccess', _521 => _521.data, 'optionalAccess', _522 => _522.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
+    if (_optionalChain([error49, 'access', _528 => _528.response, 'optionalAccess', _529 => _529.status]) === 403 && _optionalChain([error49, 'access', _530 => _530.response, 'optionalAccess', _531 => _531.data, 'optionalAccess', _532 => _532.message]) === "This operation is not available in PingOne Advanced Identity Cloud.") {
       return [];
     } else {
       throw new FrodoError(
@@ -210402,8 +210562,8 @@ async function getFullServices({
             nextDescendents
           };
         } catch (error49) {
-          if (!(_optionalChain([error49, 'access', _523 => _523.response, 'optionalAccess', _524 => _524.status]) === 403 && _optionalChain([error49, 'access', _525 => _525.response, 'optionalAccess', _526 => _526.data, 'optionalAccess', _527 => _527.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
-            const message = _optionalChain([error49, 'access', _528 => _528.response, 'optionalAccess', _529 => _529.data, 'optionalAccess', _530 => _530.message]);
+          if (!(_optionalChain([error49, 'access', _533 => _533.response, 'optionalAccess', _534 => _534.status]) === 403 && _optionalChain([error49, 'access', _535 => _535.response, 'optionalAccess', _536 => _536.data, 'optionalAccess', _537 => _537.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
+            const message = _optionalChain([error49, 'access', _538 => _538.response, 'optionalAccess', _539 => _539.data, 'optionalAccess', _540 => _540.message]);
             printMessage({
               message: `Unable to retrieve data for ${listItem._id} with error: ${message}`,
               type: "error",
@@ -210435,16 +210595,17 @@ async function putFullService({
       state: state2
     });
     const fullServiceDataCopy = cloneDeep(fullServiceData);
-    const nextDescendents = fullServiceData.nextDescendents;
-    delete fullServiceData.nextDescendents;
-    delete fullServiceData._rev;
-    delete fullServiceData.enabled;
+    const nextDescendents = fullServiceDataCopy.nextDescendents;
+    const transportType = fullServiceDataCopy.transportType;
+    delete fullServiceDataCopy.nextDescendents;
+    delete fullServiceDataCopy._rev;
+    delete fullServiceDataCopy.enabled;
     if (clean) {
       try {
         debugMessage({ message: `ServiceOps.putFullService: clean`, state: state2 });
         await deleteFullService({ serviceId, globalConfig: globalConfig2, state: state2 });
       } catch (error49) {
-        if (!(_optionalChain([error49, 'access', _531 => _531.response, 'optionalAccess', _532 => _532.status]) === 404 && _optionalChain([error49, 'access', _533 => _533.response, 'optionalAccess', _534 => _534.data, 'optionalAccess', _535 => _535.message]) === "Not Found")) {
+        if (!(_optionalChain([error49, 'access', _541 => _541.response, 'optionalAccess', _542 => _542.status]) === 404 && _optionalChain([error49, 'access', _543 => _543.response, 'optionalAccess', _544 => _544.data, 'optionalAccess', _545 => _545.message]) === "Not Found")) {
           throw new FrodoError(
             `Error deleting service '${serviceId}' before import`,
             error49
@@ -210452,13 +210613,13 @@ async function putFullService({
         }
       }
     }
-    delete fullServiceData.location;
-    if (serviceId === "email" && fullServiceData.transportType) {
-      delete fullServiceData.transportType;
+    delete fullServiceDataCopy.location;
+    if (serviceId === "email" && transportType) {
+      delete fullServiceDataCopy.transportType;
     }
     let result = await putService({
       serviceId,
-      serviceData: fullServiceData,
+      serviceData: fullServiceDataCopy,
       globalConfig: globalConfig2,
       state: state2
     });
@@ -210499,11 +210660,11 @@ async function putFullService({
         return result2;
       })
     );
-    if (serviceId === "email" && fullServiceDataCopy.transportType) {
-      fullServiceData.transportType = fullServiceDataCopy.transportType;
+    if (serviceId === "email" && transportType) {
+      fullServiceDataCopy.transportType = transportType;
       result = await putService({
         serviceId,
-        serviceData: fullServiceData,
+        serviceData: fullServiceDataCopy,
         globalConfig: globalConfig2,
         state: state2
       });
@@ -210624,8 +210785,8 @@ async function deleteFullServices({
             state: state2
           });
         } catch (error49) {
-          if (!(_optionalChain([error49, 'access', _536 => _536.response, 'optionalAccess', _537 => _537.status]) === 403 && _optionalChain([error49, 'access', _538 => _538.response, 'optionalAccess', _539 => _539.data, 'optionalAccess', _540 => _540.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
-            const message = _optionalChain([error49, 'access', _541 => _541.response, 'optionalAccess', _542 => _542.data, 'optionalAccess', _543 => _543.message]);
+          if (!(_optionalChain([error49, 'access', _546 => _546.response, 'optionalAccess', _547 => _547.status]) === 403 && _optionalChain([error49, 'access', _548 => _548.response, 'optionalAccess', _549 => _549.data, 'optionalAccess', _550 => _550.message]) === "This operation is not available in PingOne Advanced Identity Cloud.")) {
+            const message = _optionalChain([error49, 'access', _551 => _551.response, 'optionalAccess', _552 => _552.data, 'optionalAccess', _553 => _553.message]);
             printMessage({
               message: `Delete service '${serviceListItem._id}': ${message}`,
               state: state2,
@@ -210907,14 +211068,14 @@ async function exportFullConfiguration({
         "Global Agents",
         resultCallback,
         isFullAmDeployment
-      )), 'optionalAccess', async _544 => _544.agent]),
+      )), 'optionalAccess', async _554 => _554.agent]),
       authentication: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportAuthenticationSettings,
         globalStateObj,
         "Global Authentication Settings",
         resultCallback,
         isFullAmDeployment
-      )), 'optionalAccess', async _545 => _545.authentication]),
+      )), 'optionalAccess', async _555 => _555.authentication]),
       certificationTemplate: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportCertificationTemplates,
         {
@@ -210926,14 +211087,14 @@ async function exportFullConfiguration({
         "Certification Templates",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _546 => _546.certificationTemplate]),
+      )), 'optionalAccess', async _556 => _556.certificationTemplate]),
       emailTemplate: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportEmailTemplates,
         { includeDefault: includeReadOnly, state: state2 },
         "Email Templates",
         resultCallback,
         isIdmDeployment
-      )), 'optionalAccess', async _547 => _547.emailTemplate]),
+      )), 'optionalAccess', async _557 => _557.emailTemplate]),
       event: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportEvents,
         {
@@ -210945,7 +211106,7 @@ async function exportFullConfiguration({
         "Events",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _548 => _548.event]),
+      )), 'optionalAccess', async _558 => _558.event]),
       glossarySchema: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportGlossarySchemas,
         {
@@ -210957,7 +211118,7 @@ async function exportFullConfiguration({
         "Glossary Schemas",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _549 => _549.glossarySchema]),
+      )), 'optionalAccess', async _559 => _559.glossarySchema]),
       idm: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportConfigEntities,
         {
@@ -210971,15 +211132,15 @@ async function exportFullConfiguration({
         "IDM Config Entities",
         resultCallback,
         isIdmDeployment
-      )), 'optionalAccess', async _550 => _550.idm]),
+      )), 'optionalAccess', async _560 => _560.idm]),
       internalRole: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportInternalRoles,
         stateObj,
         "Internal Roles",
         resultCallback,
         isIdmDeployment
-      )), 'optionalAccess', async _551 => _551.internalRole]),
-      mapping: _optionalChain([mappings, 'optionalAccess', _552 => _552.mapping]),
+      )), 'optionalAccess', async _561 => _561.internalRole]),
+      mapping: _optionalChain([mappings, 'optionalAccess', _562 => _562.mapping]),
       nodeTypes: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportCustomNodes,
         {
@@ -210990,14 +211151,14 @@ async function exportFullConfiguration({
         },
         "Custom Nodes",
         resultCallback
-      )), 'optionalAccess', async _553 => _553.nodeTypes]),
+      )), 'optionalAccess', async _563 => _563.nodeTypes]),
       realm: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportRealms,
         stateObj,
         "Realms",
         resultCallback,
         includeReadOnly || isFullAmDeployment
-      )), 'optionalAccess', async _554 => _554.realm]),
+      )), 'optionalAccess', async _564 => _564.realm]),
       requestForm: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportRequestForms,
         {
@@ -211011,7 +211172,7 @@ async function exportFullConfiguration({
         "Request Forms",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _555 => _555.requestForm]),
+      )), 'optionalAccess', async _565 => _565.requestForm]),
       requestType: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportRequestTypes,
         {
@@ -211024,43 +211185,43 @@ async function exportFullConfiguration({
         "Request Types",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _556 => _556.requestType]),
+      )), 'optionalAccess', async _566 => _566.requestType]),
       scripttype: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportScriptTypes,
         stateObj,
         "Script Types",
         resultCallback,
         includeReadOnly || isFullAmDeployment
-      )), 'optionalAccess', async _557 => _557.scripttype]),
+      )), 'optionalAccess', async _567 => _567.scripttype]),
       secret: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSecrets,
         { options: { includeActiveValues, target }, state: state2 },
         "ESV Secrets",
         resultCallback,
         isCloudDeployment
-      )), 'optionalAccess', async _558 => _558.secret]),
+      )), 'optionalAccess', async _568 => _568.secret]),
       secretstore: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSecretStores,
         globalStateObj,
         "Global Secret Stores",
         resultCallback,
         isFullAmDeployment
-      )), 'optionalAccess', async _559 => _559.secretstore]),
+      )), 'optionalAccess', async _569 => _569.secretstore]),
       server: serverExport,
       service: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportServices,
         globalStateObj,
         "Services",
         resultCallback
-      )), 'optionalAccess', async _560 => _560.service]),
+      )), 'optionalAccess', async _570 => _570.service]),
       site: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportSites,
         stateObj,
         "Sites",
         resultCallback,
         isFullAmDeployment
-      )), 'optionalAccess', async _561 => _561.site]),
-      sync: _optionalChain([mappings, 'optionalAccess', _562 => _562.sync]),
+      )), 'optionalAccess', async _571 => _571.site]),
+      sync: _optionalChain([mappings, 'optionalAccess', _572 => _572.sync]),
       variable: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportVariables,
         {
@@ -211070,7 +211231,7 @@ async function exportFullConfiguration({
         "ESV Variables",
         resultCallback,
         isCloudDeployment
-      )), 'optionalAccess', async _563 => _563.variable]),
+      )), 'optionalAccess', async _573 => _573.variable]),
       workflow: await _asyncOptionalChain([(await exportWithErrorHandling(
         exportWorkflows,
         {
@@ -211086,7 +211247,7 @@ async function exportFullConfiguration({
         "Workflows",
         resultCallback,
         !!state2.getIsIGA()
-      )), 'optionalAccess', async _564 => _564.workflow]),
+      )), 'optionalAccess', async _574 => _574.workflow]),
       ...config5.global
     };
     if (globalConfig2.idm) {
@@ -211096,7 +211257,7 @@ async function exportFullConfiguration({
     }
     if (globalConfig2.event && globalConfig2.certificationTemplate) {
       const eventTemplateIds = new Set(
-        Object.values(globalConfig2.event).map((e) => _optionalChain([e, 'access', _565 => _565.action, 'optionalAccess', _566 => _566.template, 'optionalAccess', _567 => _567.id])).filter((i2) => i2)
+        Object.values(globalConfig2.event).map((e) => _optionalChain([e, 'access', _575 => _575.action, 'optionalAccess', _576 => _576.template, 'optionalAccess', _577 => _577.id])).filter((i2) => i2)
       );
       const templateIds = Object.keys(globalConfig2.certificationTemplate);
       for (const templateId of templateIds) {
@@ -211120,7 +211281,7 @@ async function exportFullConfiguration({
         stateObj,
         "SAML2 Providers",
         resultCallback
-      )), 'optionalAccess', async _568 => _568.saml]);
+      )), 'optionalAccess', async _578 => _578.saml]);
       const cotExport = await exportWithErrorHandling(
         exportCirclesOfTrust,
         stateObj,
@@ -211128,9 +211289,9 @@ async function exportFullConfiguration({
         resultCallback
       );
       if (saml) {
-        saml.cot = _optionalChain([cotExport, 'optionalAccess', _569 => _569.saml, 'access', _570 => _570.cot]);
+        saml.cot = _optionalChain([cotExport, 'optionalAccess', _579 => _579.saml, 'access', _580 => _580.cot]);
       } else {
-        saml = _optionalChain([cotExport, 'optionalAccess', _571 => _571.saml]);
+        saml = _optionalChain([cotExport, 'optionalAccess', _581 => _581.saml]);
       }
       realmConfig[realm2] = {
         agentGroup: await _asyncOptionalChain([(await exportWithErrorHandling(
@@ -211138,13 +211299,13 @@ async function exportFullConfiguration({
           stateObj,
           "Agent Groups",
           resultCallback
-        )), 'optionalAccess', async _572 => _572.agentGroup]),
+        )), 'optionalAccess', async _582 => _582.agentGroup]),
         agent: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportAgents,
           realmStateObj,
           "Agents",
           resultCallback
-        )), 'optionalAccess', async _573 => _573.agent]),
+        )), 'optionalAccess', async _583 => _583.agent]),
         application: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportOAuth2Clients,
           {
@@ -211153,19 +211314,19 @@ async function exportFullConfiguration({
           },
           "OAuth2 Client Applications",
           resultCallback
-        )), 'optionalAccess', async _574 => _574.application]),
+        )), 'optionalAccess', async _584 => _584.application]),
         authentication: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportAuthenticationSettings,
           realmStateObj,
           "Authentication Settings",
           resultCallback
-        )), 'optionalAccess', async _575 => _575.authentication]),
+        )), 'optionalAccess', async _585 => _585.authentication]),
         idp: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportSocialIdentityProviders,
           stateObj,
           "Social Identity Providers",
           resultCallback
-        )), 'optionalAccess', async _576 => _576.idp]),
+        )), 'optionalAccess', async _586 => _586.idp]),
         trees: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportJourneys,
           {
@@ -211179,7 +211340,7 @@ async function exportFullConfiguration({
           },
           "Journeys",
           resultCallback
-        )), 'optionalAccess', async _577 => _577.trees]),
+        )), 'optionalAccess', async _587 => _587.trees]),
         managedApplication: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportApplications,
           {
@@ -211189,7 +211350,7 @@ async function exportFullConfiguration({
           "Applications",
           resultCallback,
           isIdmDeployment
-        )), 'optionalAccess', async _578 => _578.managedApplication]),
+        )), 'optionalAccess', async _588 => _588.managedApplication]),
         policy: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportPolicies,
           {
@@ -211198,7 +211359,7 @@ async function exportFullConfiguration({
           },
           "Policies",
           resultCallback
-        )), 'optionalAccess', async _579 => _579.policy]),
+        )), 'optionalAccess', async _589 => _589.policy]),
         policyset: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportPolicySets,
           {
@@ -211207,13 +211368,13 @@ async function exportFullConfiguration({
           },
           "Policy Sets",
           resultCallback
-        )), 'optionalAccess', async _580 => _580.policyset]),
+        )), 'optionalAccess', async _590 => _590.policyset]),
         resourcetype: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportResourceTypes,
           stateObj,
           "Resource Types",
           resultCallback
-        )), 'optionalAccess', async _581 => _581.resourcetype]),
+        )), 'optionalAccess', async _591 => _591.resourcetype]),
         saml,
         script: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportScripts,
@@ -211228,19 +211389,19 @@ async function exportFullConfiguration({
           },
           "Scripts",
           resultCallback
-        )), 'optionalAccess', async _582 => _582.script]),
+        )), 'optionalAccess', async _592 => _592.script]),
         secretstore: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportSecretStores,
           realmStateObj,
           "Secret Stores",
           resultCallback
-        )), 'optionalAccess', async _583 => _583.secretstore]),
+        )), 'optionalAccess', async _593 => _593.secretstore]),
         service: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportServices,
           realmStateObj,
           "Services",
           resultCallback
-        )), 'optionalAccess', async _584 => _584.service]),
+        )), 'optionalAccess', async _594 => _594.service]),
         theme: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportThemes,
           {
@@ -211249,7 +211410,7 @@ async function exportFullConfiguration({
           "Themes",
           resultCallback,
           isIdmDeployment
-        )), 'optionalAccess', async _585 => _585.theme]),
+        )), 'optionalAccess', async _595 => _595.theme]),
         trustedJwtIssuer: await _asyncOptionalChain([(await exportWithErrorHandling(
           exportOAuth2TrustedJwtIssuers,
           {
@@ -211258,7 +211419,7 @@ async function exportFullConfiguration({
           },
           "Trusted JWT Issuers",
           resultCallback
-        )), 'optionalAccess', async _586 => _586.trustedJwtIssuer]),
+        )), 'optionalAccess', async _596 => _596.trustedJwtIssuer]),
         ...config5.realm[realm2]
       };
       if (realmConfig[realm2].service && realmConfig[realm2].service["SocialIdentityProviders"]) {
@@ -212994,13 +213155,13 @@ async function getUserCount({
   }).get(urlString, {
     withCredentials: true
   });
-  if (typeof _optionalChain([data2, 'optionalAccess', _587 => _587.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _597 => _597.totalPagedResults]) === "number" && data2.totalPagedResults >= 0) {
     return data2.totalPagedResults;
   }
-  if (typeof _optionalChain([data2, 'optionalAccess', _588 => _588.resultCount]) === "number" && data2.resultCount >= 0) {
+  if (typeof _optionalChain([data2, 'optionalAccess', _598 => _598.resultCount]) === "number" && data2.resultCount >= 0) {
     return data2.resultCount;
   }
-  return Array.isArray(_optionalChain([data2, 'optionalAccess', _589 => _589.result])) ? data2.result.length : 0;
+  return Array.isArray(_optionalChain([data2, 'optionalAccess', _599 => _599.result])) ? data2.result.length : 0;
 }
 async function getUserConfig({
   userId,
@@ -213060,7 +213221,7 @@ async function getUserConfig({
         current = current[part];
       }
     } catch (e) {
-      if (e.httpStatus === 404 || _optionalChain([e, 'access', _590 => _590.response, 'optionalAccess', _591 => _591.status]) === 404) {
+      if (e.httpStatus === 404 || _optionalChain([e, 'access', _600 => _600.response, 'optionalAccess', _601 => _601.status]) === 404) {
       } else {
         printMessage({
           message: `Error exporting config for user with id '${userId}' from url '${urlString}': ${e.message}`,
@@ -215650,13 +215811,13 @@ var helpMetadata = [
   {
     typeName: "Journey",
     methodName: "exportJourney",
-    signature: "exportJourney( treeId: string, options?: TreeExportOptions ): Promise<SingleTreeExportInterface>",
+    signature: "exportJourney( treeId: string, options?: TreeExportOptions ): Promise<MultiTreeExportInterface>",
     description: "Create export data for a tree/journey with all its nodes and dependencies. The export data can be written to a file as is.",
     params: [
       { name: "treeId", type: "string", description: "tree id/name" },
       { name: "options", type: "TreeExportOptions", description: "export options" }
     ],
-    returns: "{Promise<SingleTreeExportInterface>} a promise that resolves to an object containing the tree and all its nodes and dependencies"
+    returns: "{Promise<MultiTreeExportInterface>} a promise that resolves to an object containing the tree and any exported dependencies"
   },
   {
     typeName: "Journey",
@@ -217605,9 +217766,11 @@ var helpMetadata = [
   {
     typeName: "Script",
     methodName: "readScripts",
-    signature: "readScripts(): Promise<ScriptSkeleton[]>",
+    signature: "readScripts(filter?: ScriptFilter): Promise<ScriptSkeleton[]>",
     description: "Read all scripts",
-    params: [],
+    params: [
+      { name: "filter", type: "ScriptFilter", description: "Optional script filter" }
+    ],
     returns: "{Promise<ScriptSkeleton[]>} a promise that resolves to an array of script objects"
   },
   {
@@ -217686,10 +217849,11 @@ var helpMetadata = [
   {
     typeName: "Script",
     methodName: "deleteScripts",
-    signature: "deleteScripts( resultCallback?: ResultCallback<ScriptSkeleton> ): Promise<ScriptSkeleton[]>",
+    signature: "deleteScripts( resultCallback?: ResultCallback<ScriptSkeleton>, filter?: ScriptFilter ): Promise<ScriptSkeleton[]>",
     description: "Delete all non-default scripts",
     params: [
-      { name: "resultCallback", type: "ResultCallback", description: "Optional callback to process individual results" }
+      { name: "resultCallback", type: "ResultCallback", description: "Optional callback to process individual results" },
+      { name: "filter", type: "ScriptFilter", description: "Optional script filter" }
     ],
     returns: "{Promise<ScriptSkeleton[]>} a promise that resolves to an array of script objects"
   },
@@ -219668,6 +219832,14 @@ var helpMetadata = [
     ],
     returns: "{Promise<boolean>} true if successful, false otherwise"
   },
+  {
+    typeName: "Startup",
+    methodName: "readStatus",
+    signature: "readStatus(): Promise<RestartStatus>",
+    description: "Get the current restart status of the environment",
+    params: [],
+    returns: "{Promise<RestartStatus>} the current restart status"
+  },
   {
     typeName: "Variable",
     methodName: "readVariable",
@@ -222508,6 +222680,31 @@ var CAPABILITY_META = {
     supportsRealm: true,
     notes: "Update (or upsert) a script by id. Prefer namedArgs { scriptId, scriptData }."
   },
+  "script.deleteScripts": {
+    argumentMode: "named",
+    parameters: [
+      {
+        name: "resultCallback",
+        type: "ResultCallback<ScriptSkeleton>",
+        required: false,
+        position: 0,
+        description: "Optional callback to process each deleted script as it is removed."
+      },
+      {
+        name: "filter",
+        type: "ScriptFilter",
+        required: false,
+        position: 1,
+        description: "Optional script filter selecting which non-default scripts to delete.",
+        schema: {
+          type: "object",
+          additionalProperties: true
+        }
+      }
+    ],
+    supportsRealm: true,
+    notes: "Prefer namedArgs { filter } for MCP callers. resultCallback is primarily intended for in-process library usage."
+  },
   "oauth2oidc.client.createOAuth2Client": {
     argumentMode: "named",
     parameters: [
@@ -222834,11 +223031,11 @@ function buildDescriptor(path72) {
   const annotations = inferAnnotations(operationType, mutating, destructive);
   const sourcePath = [...modulePath, methodName].join(".");
   const meta3 = resolveCapabilityMeta(sourcePath);
-  const argumentMode = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _592 => _592.argumentMode]), () => ( inferArgumentMode(operationType)));
-  const parameters = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _593 => _593.parameters]), () => ( inferParameters(methodName, objectType2, operationType)));
-  const supportsPaging = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _594 => _594.supportsPaging]), () => ( (operationType === "list" || operationType === "search")));
-  const supportsIncludeTotal = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _595 => _595.supportsIncludeTotal]), () => ( (operationType === "list" || operationType === "search")));
-  const supportsRealm = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _596 => _596.supportsRealm]), () => ( kind === "generic"));
+  const argumentMode = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _602 => _602.argumentMode]), () => ( inferArgumentMode(operationType)));
+  const parameters = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _603 => _603.parameters]), () => ( inferParameters(methodName, objectType2, operationType)));
+  const supportsPaging = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _604 => _604.supportsPaging]), () => ( (operationType === "list" || operationType === "search")));
+  const supportsIncludeTotal = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _605 => _605.supportsIncludeTotal]), () => ( (operationType === "list" || operationType === "search")));
+  const supportsRealm = _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _606 => _606.supportsRealm]), () => ( kind === "generic"));
   return {
     id: sourcePath,
     toolName: `frodo.${sourcePath}`,
@@ -222849,7 +223046,7 @@ function buildDescriptor(path72) {
     operationType,
     argumentMode,
     ...parameters !== void 0 && { parameters },
-    ..._optionalChain([meta3, 'optionalAccess', _597 => _597.scope]) !== void 0 && { scope: meta3.scope },
+    ..._optionalChain([meta3, 'optionalAccess', _607 => _607.scope]) !== void 0 && { scope: meta3.scope },
     supportsRealm,
     supportsPaging,
     supportsIncludeTotal,
@@ -222857,17 +223054,17 @@ function buildDescriptor(path72) {
     riskClass,
     mutating,
     destructive,
-    deploymentTypes: _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _598 => _598.deploymentTypes]), () => ( ["any"])),
-    ..._optionalChain([meta3, 'optionalAccess', _599 => _599.preferredDeploymentTypes]) !== void 0 && {
+    deploymentTypes: _nullishCoalesce(_optionalChain([meta3, 'optionalAccess', _608 => _608.deploymentTypes]), () => ( ["any"])),
+    ..._optionalChain([meta3, 'optionalAccess', _609 => _609.preferredDeploymentTypes]) !== void 0 && {
       preferredDeploymentTypes: meta3.preferredDeploymentTypes
     },
-    ..._optionalChain([meta3, 'optionalAccess', _600 => _600.identitySurface]) !== void 0 && {
+    ..._optionalChain([meta3, 'optionalAccess', _610 => _610.identitySurface]) !== void 0 && {
       identitySurface: meta3.identitySurface
     },
-    ..._optionalChain([meta3, 'optionalAccess', _601 => _601.objectTypePatterns]) !== void 0 && {
+    ..._optionalChain([meta3, 'optionalAccess', _611 => _611.objectTypePatterns]) !== void 0 && {
       objectTypePatterns: meta3.objectTypePatterns
     },
-    ..._optionalChain([meta3, 'optionalAccess', _602 => _602.notes]) !== void 0 && {
+    ..._optionalChain([meta3, 'optionalAccess', _612 => _612.notes]) !== void 0 && {
       notes: meta3.notes
     },
     requiredScopes: [],
@@ -223188,7 +223385,7 @@ function createToolRuntime(manifest, capabilities, options = {}) {
   const paginationWarningThreshold = _nullishCoalesce(options.paginationWarningThreshold, () => ( 1e3));
   const resultWarningThresholdBytes = _nullishCoalesce(options.resultWarningThresholdBytes, () => ( 65536));
   const executeTool = async (request) => {
-    if (!_optionalChain([request, 'optionalAccess', _603 => _603.toolName])) {
+    if (!_optionalChain([request, 'optionalAccess', _613 => _613.toolName])) {
       throw new FrodoError("MCP runtime error: missing toolName in request.");
     }
     if (request.toolName === manifest.discoveryTool.toolName) {
@@ -223305,10 +223502,10 @@ function assertDeploymentCompatibility(descriptor, context) {
   );
 }
 function resolveContextDeploymentType(context) {
-  if (!_optionalChain([context, 'optionalAccess', _604 => _604.auth])) {
+  if (!_optionalChain([context, 'optionalAccess', _614 => _614.auth])) {
     return void 0;
   }
-  const rawType = context.auth.mode === "state-config" ? _optionalChain([context, 'access', _605 => _605.auth, 'access', _606 => _606.config, 'optionalAccess', _607 => _607.deploymentType]) : context.auth.deploymentType;
+  const rawType = context.auth.mode === "state-config" ? _optionalChain([context, 'access', _615 => _615.auth, 'access', _616 => _616.config, 'optionalAccess', _617 => _617.deploymentType]) : context.auth.deploymentType;
   if (typeof rawType !== "string") {
     return void 0;
   }
@@ -223319,7 +223516,7 @@ function resolveContextDeploymentType(context) {
   return void 0;
 }
 function resolveRequestScopedFrodo(context, frodoRoot = frodo) {
-  if (!_optionalChain([context, 'optionalAccess', _608 => _608.auth])) {
+  if (!_optionalChain([context, 'optionalAccess', _618 => _618.auth])) {
     throw new FrodoError("MCP runtime error: missing auth context.");
   }
   switch (context.auth.mode) {
@@ -223571,7 +223768,7 @@ function toInvocationArgs(raw, descriptor) {
     return maybeArgs.positionalArgs;
   }
   if (maybeArgs.namedArgs && typeof maybeArgs.namedArgs === "object") {
-    if (_optionalChain([descriptor, 'optionalAccess', _609 => _609.parameters]) && descriptor.parameters.length > 0) {
+    if (_optionalChain([descriptor, 'optionalAccess', _619 => _619.parameters]) && descriptor.parameters.length > 0) {
       return descriptor.parameters.slice().sort(
         (left, right) => (_nullishCoalesce(left.position, () => ( Number.MAX_SAFE_INTEGER))) - (_nullishCoalesce(right.position, () => ( Number.MAX_SAFE_INTEGER)))
       ).map((parameter) => {
@@ -223633,14 +223830,14 @@ function validateInvocationArguments(descriptor, args) {
       `MCP runtime error: descriptor '${descriptor.id}' does not accept named argument(s) ${unknownNames.join(", ")}. Allowed parameters: ${formatDescriptorParameters(descriptor)}.`
     );
   }
-  const missingRequired = descriptor.parameters.filter((parameter) => parameter.required).filter((parameter) => _optionalChain([args, 'access', _610 => _610.namedArgs, 'optionalAccess', _611 => _611[parameter.name]]) === void 0).map((parameter) => parameter.name);
+  const missingRequired = descriptor.parameters.filter((parameter) => parameter.required).filter((parameter) => _optionalChain([args, 'access', _620 => _620.namedArgs, 'optionalAccess', _621 => _621[parameter.name]]) === void 0).map((parameter) => parameter.name);
   if (missingRequired.length > 0) {
     throw new FrodoError(
       `MCP runtime error: descriptor '${descriptor.id}' is missing required named argument(s): ${missingRequired.join(", ")}. Allowed parameters: ${formatDescriptorParameters(descriptor)}.`
     );
   }
   for (const parameter of descriptor.parameters) {
-    const value = _optionalChain([args, 'access', _612 => _612.namedArgs, 'optionalAccess', _613 => _613[parameter.name]]);
+    const value = _optionalChain([args, 'access', _622 => _622.namedArgs, 'optionalAccess', _623 => _623[parameter.name]]);
     if (value === void 0) {
       continue;
     }
@@ -223648,7 +223845,7 @@ function validateInvocationArguments(descriptor, args) {
   }
 }
 function resolveNamedOrGenericParameterValue(parameter, args) {
-  const providedValue = _optionalChain([args, 'access', _614 => _614.namedArgs, 'optionalAccess', _615 => _615[parameter.name]]);
+  const providedValue = _optionalChain([args, 'access', _624 => _624.namedArgs, 'optionalAccess', _625 => _625[parameter.name]]);
   if (providedValue !== void 0) {
     return providedValue;
   }
@@ -224059,7 +224256,7 @@ function buildPaginationMetadata(data2, args, operationType, paginationWarningTh
 }
 function buildUnsupportedGenericCombinationMessage(toolName, domain2, objectType2, discovery) {
   const objectTypeKey = `${domain2}.${objectType2}`;
-  const supportEntry = _optionalChain([discovery, 'access', _616 => _616.objectTypeOperationSupport, 'optionalAccess', _617 => _617.find, 'call', _618 => _618(
+  const supportEntry = _optionalChain([discovery, 'access', _626 => _626.objectTypeOperationSupport, 'optionalAccess', _627 => _627.find, 'call', _628 => _628(
     (entry) => entry.domain === domain2 && entry.objectType === objectType2
   )]);
   if (supportEntry) {
@@ -224067,7 +224264,7 @@ function buildUnsupportedGenericCombinationMessage(toolName, domain2, objectType
     return `MCP runtime error: tool '${toolName}' does not support domain '${domain2}' and objectType '${objectType2}'. Supported operations for '${objectTypeKey}': ${supportedList}. Use 'frodo_discover' to inspect supported combinations.`;
   }
   const knownObjectTypes = discovery.objectTypesByDomain[domain2];
-  if (_optionalChain([knownObjectTypes, 'optionalAccess', _619 => _619.length])) {
+  if (_optionalChain([knownObjectTypes, 'optionalAccess', _629 => _629.length])) {
     return `MCP runtime error: tool '${toolName}' does not support domain '${domain2}' and objectType '${objectType2}'. Known object types for domain '${domain2}': ${knownObjectTypes.join(", ")}. Use 'frodo_discover' to inspect supported combinations.`;
   }
   return `MCP runtime error: tool '${toolName}' does not support domain '${domain2}' and objectType '${objectType2}'. Use 'frodo_discover' to inspect supported combinations.`;
@@ -224116,7 +224313,7 @@ function composeCapabilityPolicy(presetName, override) {
   return {
     ...preset,
     ...override,
-    name: _optionalChain([override, 'optionalAccess', _620 => _620.name]) || preset.name
+    name: _optionalChain([override, 'optionalAccess', _630 => _630.name]) || preset.name
   };
 }
 function createMcpService(options = {}) {
@@ -224327,7 +224524,7 @@ function v43(options, buf, offset) {
     return native_default3.randomUUID();
   }
   options = options || {};
-  const rnds = _nullishCoalesce(_nullishCoalesce(options.random, () => ( _optionalChain([options, 'access', _621 => _621.rng, 'optionalCall', _622 => _622()]))), () => ( rng3()));
+  const rnds = _nullishCoalesce(_nullishCoalesce(options.random, () => ( _optionalChain([options, 'access', _631 => _631.rng, 'optionalCall', _632 => _632()]))), () => ( rng3()));
   if (rnds.length < 16) {
     throw new Error("Random bytes length must be >= 16");
   }
@@ -224832,7 +225029,7 @@ function getEffectiveCommandStabilityMetadata(command) {
       if (stabilityLevelPriority[metadata.level] > stabilityLevelPriority[level]) {
         level = metadata.level;
       }
-      if (!gate && _optionalChain([metadata, 'access', _623 => _623.gate, 'optionalAccess', _624 => _624.requiredOptIn])) {
+      if (!gate && _optionalChain([metadata, 'access', _633 => _633.gate, 'optionalAccess', _634 => _634.requiredOptIn])) {
         gate = metadata.gate;
       }
     }
@@ -224885,7 +225082,7 @@ function decorateDescriptionWithStability(description, target) {
       metadata.level
     )
   ];
-  if (_optionalChain([metadata, 'access', _625 => _625.gate, 'optionalAccess', _626 => _626.requiredOptIn])) {
+  if (_optionalChain([metadata, 'access', _635 => _635.gate, 'optionalAccess', _636 => _636.requiredOptIn])) {
     badges.push(
       colorizeStabilityBadge("[Opt-in required]", metadata.level, true)
     );
@@ -225415,7 +225612,7 @@ function isSingleDeploymentType(types) {
 }
 function collectEnvironmentVariableGroups(command, includeAll = false, supportedTypes) {
   const groupedEntries = /* @__PURE__ */ new Map();
-  const effectiveTypes = _optionalChain([command, 'optionalAccess', _627 => _627.types]) || supportedTypes;
+  const effectiveTypes = _optionalChain([command, 'optionalAccess', _637 => _637.types]) || supportedTypes;
   function getOrCreate(group) {
     let data2 = groupedEntries.get(group);
     if (!data2) {
@@ -225470,7 +225667,7 @@ function collectEnvironmentVariableGroups(command, includeAll = false, supported
   return groupedEntries;
 }
 function renderEnvironmentVariableGroups(groupedEntries, command, supportedTypes) {
-  const effectiveTypes = _optionalChain([command, 'optionalAccess', _628 => _628.types]) || supportedTypes;
+  const effectiveTypes = _optionalChain([command, 'optionalAccess', _638 => _638.types]) || supportedTypes;
   const isSingleType = isSingleDeploymentType(effectiveTypes);
   const sections = environmentVariableGroupOrder.flatMap((group) => {
     const groupData = groupedEntries.get(group);
@@ -225700,7 +225897,7 @@ function isStabilityGateSatisfied(command, gate) {
   const envVarName = gate.envVarName || "FRODO_ENABLE_PREVIEW";
   const options = command.optsWithGlobals();
   const optionKey = toOptionAttributeName(optionName);
-  const optionEnabled = isTruthyOptInValue(_optionalChain([options, 'optionalAccess', _629 => _629[optionKey]]));
+  const optionEnabled = isTruthyOptInValue(_optionalChain([options, 'optionalAccess', _639 => _639[optionKey]]));
   const envEnabled = isTruthyOptInValue(process.env[envVarName]);
   switch (mode2) {
     case "option-only":
@@ -225726,7 +225923,7 @@ function enforceOptionStabilityAndWarn(actionCommand) {
     const commandPath = getCommandPath(actionCommand);
     const optionLabel = getOptionLabel(option);
     const warningKey = `${commandPath}::${optionLabel}`;
-    if (_optionalChain([metadata, 'access', _630 => _630.gate, 'optionalAccess', _631 => _631.requiredOptIn])) {
+    if (_optionalChain([metadata, 'access', _640 => _640.gate, 'optionalAccess', _641 => _641.requiredOptIn])) {
       const gate = metadata.gate;
       if (!isStabilityGateSatisfied(actionCommand, gate)) {
         const optionName = gate.optionName || "enable-preview";
@@ -225739,7 +225936,7 @@ function enforceOptionStabilityAndWarn(actionCommand) {
       }
     }
     if (!warnedStabilityOptions.has(warningKey)) {
-      const suffix = _optionalChain([metadata, 'access', _632 => _632.gate, 'optionalAccess', _633 => _633.requiredOptIn]) ? metadata.level === "deprecated" ? " This option is opt-in, deprecated, and may be removed in a future release." : " This option is opt-in and may change without notice." : metadata.level === "deprecated" ? " This option is deprecated and may be removed in a future release." : " This option may change without notice.";
+      const suffix = _optionalChain([metadata, 'access', _642 => _642.gate, 'optionalAccess', _643 => _643.requiredOptIn]) ? metadata.level === "deprecated" ? " This option is opt-in, deprecated, and may be removed in a future release." : " This option is opt-in and may change without notice." : metadata.level === "deprecated" ? " This option is deprecated and may be removed in a future release." : " This option may change without notice.";
       printMessage2(
         `${formatStabilityLevel(metadata.level)} option in use: '${optionLabel}' on command '${commandPath}'.${suffix}`,
         "warn"
@@ -225754,7 +225951,7 @@ function enforceStabilityAndWarn(actionCommand) {
     return;
   }
   const commandPath = getCommandPath(actionCommand);
-  if (_optionalChain([metadata, 'access', _634 => _634.gate, 'optionalAccess', _635 => _635.requiredOptIn])) {
+  if (_optionalChain([metadata, 'access', _644 => _644.gate, 'optionalAccess', _645 => _645.requiredOptIn])) {
     const gate = metadata.gate;
     if (!isStabilityGateSatisfied(actionCommand, gate)) {
       const optionName = gate.optionName || "enable-preview";
@@ -225767,7 +225964,7 @@ function enforceStabilityAndWarn(actionCommand) {
     }
   }
   if (!warnedStabilityCommands.has(commandPath)) {
-    const gateSuffix = _optionalChain([metadata, 'access', _636 => _636.gate, 'optionalAccess', _637 => _637.requiredOptIn]) ? metadata.level === "deprecated" ? " This command is opt-in, deprecated, and may be removed in a future release." : " This feature is opt-in and may change without notice." : metadata.level === "deprecated" ? " This command is deprecated and may be removed in a future release." : " This feature may change without notice.";
+    const gateSuffix = _optionalChain([metadata, 'access', _646 => _646.gate, 'optionalAccess', _647 => _647.requiredOptIn]) ? metadata.level === "deprecated" ? " This command is opt-in, deprecated, and may be removed in a future release." : " This feature is opt-in and may change without notice." : metadata.level === "deprecated" ? " This command is deprecated and may be removed in a future release." : " This feature may change without notice.";
     printMessage2(
       `${formatStabilityLevel(metadata.level)} feature in use: '${commandPath}'.${gateSuffix}`,
       "warn"
@@ -225816,7 +226013,7 @@ var FrodoStubCommand = class extends (_a = Command, STABILITY_METADATA_KEY, _a)
       sortSubcommands: true,
       sortOptions: true
     });
-    _optionalChain([this, 'access', _638 => _638.options, 'access', _639 => _639.find, 'call', _640 => _640((option) => option.name() === "help"), 'optionalAccess', _641 => _641.helpGroup, 'call', _642 => _642(HELP_OPTIONS_HEADING)]);
+    _optionalChain([this, 'access', _648 => _648.options, 'access', _649 => _649.find, 'call', _650 => _650((option) => option.name() === "help"), 'optionalAccess', _651 => _651.helpGroup, 'call', _652 => _652(HELP_OPTIONS_HEADING)]);
     this.addHelpText("after", () => {
       if (!isFullHelpRequested()) {
         return "";
@@ -225854,7 +226051,7 @@ var FrodoStubCommand = class extends (_a = Command, STABILITY_METADATA_KEY, _a)
    * @returns This command for chaining.
    */
   withStability(level, gate) {
-    const normalizedGate = _optionalChain([gate, 'optionalAccess', _643 => _643.requiredOptIn]) ? {
+    const normalizedGate = _optionalChain([gate, 'optionalAccess', _653 => _653.requiredOptIn]) ? {
       requiredOptIn: true,
       optionName: gate.optionName || "enable-preview",
       envVarName: gate.envVarName || "FRODO_ENABLE_PREVIEW",
@@ -225862,7 +226059,7 @@ var FrodoStubCommand = class extends (_a = Command, STABILITY_METADATA_KEY, _a)
       mode: gate.mode || "option-or-env"
     } : gate;
     setStabilityMetadata(this, { level, gate: normalizedGate });
-    if (_optionalChain([normalizedGate, 'optionalAccess', _644 => _644.requiredOptIn])) {
+    if (_optionalChain([normalizedGate, 'optionalAccess', _654 => _654.requiredOptIn])) {
       const optionName = normalizedGate.optionName || "enable-preview";
       const optionExists = this.options.some(
         (option) => option.name() === optionName || option.attributeName() === optionName
@@ -226203,7 +226400,7 @@ var FrodoCommand = class extends FrodoStubCommand {
     for (const opt of defaultOpts) {
       if (!commandOmits.has(opt.name())) this.addOption(opt);
     }
-    _optionalChain([this, 'access', _645 => _645.options, 'access', _646 => _646.find, 'call', _647 => _647((option) => option.name() === "help"), 'optionalAccess', _648 => _648.helpGroup, 'call', _649 => _649(HELP_OPTIONS_HEADING)]);
+    _optionalChain([this, 'access', _655 => _655.options, 'access', _656 => _656.find, 'call', _657 => _657((option) => option.name() === "help"), 'optionalAccess', _658 => _658.helpGroup, 'call', _659 => _659(HELP_OPTIONS_HEADING)]);
     this.addHelpText(
       "after",
       () => isFullHelpRequested() ? formatEnvironmentVariables(this) : ""
@@ -228044,7 +228241,7 @@ In AM, create a trusted issuer in the ${state.getRealm()} realm with the followi
       ]);
       issuer.push([
         "Allowed Subjects              "["brightCyan"],
-        _optionalChain([artefacts, 'access', _650 => _650.issuer, 'access', _651 => _651.allowedSubjects, 'optionalAccess', _652 => _652.value, 'access', _653 => _653.length]) ? _optionalChain([artefacts, 'access', _654 => _654.issuer, 'access', _655 => _655.allowedSubjects, 'optionalAccess', _656 => _656.value, 'access', _657 => _657.join, 'call', _658 => _658(", ")]) : `Any ${state.getRealm()} realm user`
+        _optionalChain([artefacts, 'access', _660 => _660.issuer, 'access', _661 => _661.allowedSubjects, 'optionalAccess', _662 => _662.value, 'access', _663 => _663.length]) ? _optionalChain([artefacts, 'access', _664 => _664.issuer, 'access', _665 => _665.allowedSubjects, 'optionalAccess', _666 => _666.value, 'access', _667 => _667.join, 'call', _668 => _668(", ")]) : `Any ${state.getRealm()} realm user`
       ]);
       issuer.push([
         "JWKS (Public Key)"["brightCyan"],
@@ -228172,7 +228369,7 @@ async function executeRfc7523AuthZGrantFlow2(clientId, iss, jwk, sub, scope, jso
     stopProgressIndicator2(
       spinnerId,
       `Error executing rfc7523 authz grant flow: ${stringify3(
-        _optionalChain([error49, 'access', _659 => _659.response, 'optionalAccess', _660 => _660.data]) || error49.message
+        _optionalChain([error49, 'access', _669 => _669.response, 'optionalAccess', _670 => _670.data]) || error49.message
       )}`,
       "fail"
     );
@@ -229626,11 +229823,11 @@ function normalizeAgentImportData(importData) {
 function resolveAgentStatus(agent) {
   switch (agent._type._id) {
     case "AIAgent":
-      return _nullishCoalesce(_nullishCoalesce(_optionalChain([agent, 'access', _661 => _661["coreOAuth2ClientConfig"], 'optionalAccess', _662 => _662["status"], 'optionalAccess', _663 => _663["value"]]), () => ( _optionalChain([agent, 'access', _664 => _664["coreOAuth2ClientConfig"], 'optionalAccess', _665 => _665["status"]]))), () => ( "Unknown"));
+      return _nullishCoalesce(_nullishCoalesce(_optionalChain([agent, 'access', _671 => _671["coreOAuth2ClientConfig"], 'optionalAccess', _672 => _672["status"], 'optionalAccess', _673 => _673["value"]]), () => ( _optionalChain([agent, 'access', _674 => _674["coreOAuth2ClientConfig"], 'optionalAccess', _675 => _675["status"]]))), () => ( "Unknown"));
     case "J2EEAgent":
-      return _nullishCoalesce(_optionalChain([agent, 'access', _666 => _666["globalJ2EEAgentConfig"], 'optionalAccess', _667 => _667["status"]]), () => ( "Unknown"));
+      return _nullishCoalesce(_optionalChain([agent, 'access', _676 => _676["globalJ2EEAgentConfig"], 'optionalAccess', _677 => _677["status"]]), () => ( "Unknown"));
     case "WebAgent":
-      return _nullishCoalesce(_optionalChain([agent, 'access', _668 => _668["globalWebAgentConfig"], 'optionalAccess', _669 => _669["status"]]), () => ( "Unknown"));
+      return _nullishCoalesce(_optionalChain([agent, 'access', _678 => _678["globalWebAgentConfig"], 'optionalAccess', _679 => _679["status"]]), () => ( "Unknown"));
     case "IdentityGatewayAgent":
       return _nullishCoalesce(agent["status"], () => ( "Unknown"));
     default:
@@ -236512,9 +236709,9 @@ function getLegacyMappingsFromFiles(files) {
   if (syncFiles.length === 1) {
     const file2 = syncFiles[0];
     const jsonData = JSON.parse(file2.content);
-    const syncData = _nullishCoalesce(jsonData.sync, () => ( _optionalChain([jsonData, 'access', _670 => _670.idm, 'optionalAccess', _671 => _671.sync])));
+    const syncData = _nullishCoalesce(jsonData.sync, () => ( _optionalChain([jsonData, 'access', _680 => _680.idm, 'optionalAccess', _681 => _681.sync])));
     const syncJsonDir = sysPath2.default.dirname(file2.path);
-    if (_optionalChain([syncData, 'optionalAccess', _672 => _672.mappings])) {
+    if (_optionalChain([syncData, 'optionalAccess', _682 => _682.mappings])) {
       for (const mapping of syncData.mappings) {
         let resolvedMapping;
         if (typeof mapping === "string") {
@@ -236815,7 +237012,7 @@ async function importConfigEntityByIdFromFile(entityId, file2, envFile, validate
       importData = { idm: { managed: managedData } };
     } else {
       importData = JSON.parse(fileData);
-      const entity = _optionalChain([importData, 'access', _673 => _673.idm, 'optionalAccess', _674 => _674[entityId]]);
+      const entity = _optionalChain([importData, 'access', _683 => _683.idm, 'optionalAccess', _684 => _684[entityId]]);
       if (entity) {
         const baseDir = sysPath2.default.dirname(filePath);
         resolveAllExtractedScriptsForImport(entity, baseDir);
@@ -237192,12 +237389,12 @@ function getManagedObjectsFromFiles(files) {
   };
   if (managedFiles.length === 1) {
     const jsonData = JSON.parse(managedFiles[0].content);
-    const managedData = _nullishCoalesce(jsonData.managed, () => ( _optionalChain([jsonData, 'access', _675 => _675.idm, 'optionalAccess', _676 => _676.managed])));
+    const managedData = _nullishCoalesce(jsonData.managed, () => ( _optionalChain([jsonData, 'access', _685 => _685.idm, 'optionalAccess', _686 => _686.managed])));
     const managedJsonDir = managedFiles[0].path.substring(
       0,
       managedFiles[0].path.indexOf("/managed.idm.json")
     );
-    if (_optionalChain([managedData, 'optionalAccess', _677 => _677.objects])) {
+    if (_optionalChain([managedData, 'optionalAccess', _687 => _687.objects])) {
       for (const object3 of managedData.objects) {
         let resolvedObject;
         if (typeof object3 === "string") {
@@ -237225,7 +237422,7 @@ function getLastString(path16) {
 function getObjectByPath(obj, path16) {
   return path16.split(".").reduce((acc, key) => {
     const realKey = /^\d+$/.test(key) ? Number(key) : key;
-    return _optionalChain([acc, 'optionalAccess', _678 => _678[realKey]]);
+    return _optionalChain([acc, 'optionalAccess', _688 => _688[realKey]]);
   }, obj);
 }
 function getObjectByPathExcludeLast(obj, path16) {
@@ -239360,7 +239557,7 @@ async function importScriptsFromFiles(watch2, options, validateScripts) {
     //       !path?.endsWith('.script.groovy')
     //     : // in regular mode, ignore everything but frodo script exports
     //       stats?.isFile() && !path?.endsWith('.script.json'),
-    ignored: (path16, stats) => _optionalChain([stats, 'optionalAccess', _679 => _679.isFile, 'call', _680 => _680()]) && !_optionalChain([path16, 'optionalAccess', _681 => _681.endsWith, 'call', _682 => _682(".script.json")]) && !_optionalChain([path16, 'optionalAccess', _683 => _683.endsWith, 'call', _684 => _684(".script.js")]) && !_optionalChain([path16, 'optionalAccess', _685 => _685.endsWith, 'call', _686 => _686(".script.groovy")]),
+    ignored: (path16, stats) => _optionalChain([stats, 'optionalAccess', _689 => _689.isFile, 'call', _690 => _690()]) && !_optionalChain([path16, 'optionalAccess', _691 => _691.endsWith, 'call', _692 => _692(".script.json")]) && !_optionalChain([path16, 'optionalAccess', _693 => _693.endsWith, 'call', _694 => _694(".script.js")]) && !_optionalChain([path16, 'optionalAccess', _695 => _695.endsWith, 'call', _696 => _696(".script.groovy")]),
     persistent: watch2,
     ignoreInitial: false
   });
@@ -239487,14 +239684,14 @@ async function deleteAllScripts() {
 }
 function separateScriptsFromFullExport(fullExport) {
   const scripts = { realm: {} };
-  if (!_optionalChain([fullExport, 'optionalAccess', _687 => _687.realm]) || typeof fullExport.realm !== "object") {
+  if (!_optionalChain([fullExport, 'optionalAccess', _697 => _697.realm]) || typeof fullExport.realm !== "object") {
     return scripts;
   }
   for (const [realm2, realmExport] of Object.entries(fullExport.realm)) {
     if (!scripts.realm[realm2]) {
       scripts.realm[realm2] = {};
     }
-    scripts.realm[realm2].script = _nullishCoalesce(_optionalChain([realmExport, 'optionalAccess', _688 => _688.script]), () => ( {}));
+    scripts.realm[realm2].script = _nullishCoalesce(_optionalChain([realmExport, 'optionalAccess', _698 => _698.script]), () => ( {}));
     if (realmExport && typeof realmExport === "object") {
       delete realmExport.script;
     }
@@ -239505,9 +239702,9 @@ function getScriptLocations(configuration, scriptName) {
   const locations = [];
   const regex2 = new RegExp(`require\\(['|"]${scriptName}['|"]\\)`);
   for (const [realm2, realmExport] of Object.entries(
-    _nullishCoalesce(_optionalChain([configuration, 'optionalAccess', _689 => _689.realm]), () => ( {}))
+    _nullishCoalesce(_optionalChain([configuration, 'optionalAccess', _699 => _699.realm]), () => ( {}))
   )) {
-    for (const scriptData of Object.values(_nullishCoalesce(_optionalChain([realmExport, 'optionalAccess', _690 => _690.script]), () => ( {})))) {
+    for (const scriptData of Object.values(_nullishCoalesce(_optionalChain([realmExport, 'optionalAccess', _700 => _700.script]), () => ( {})))) {
       let scriptString = scriptData.script;
       if (Array.isArray(scriptData.script)) {
         scriptString = scriptData.script.join("\n");
@@ -239544,7 +239741,7 @@ var {
 } = frodo.utils;
 var { stringify: stringify5 } = frodo.utils.json;
 function getOneLineDescription2(nodeObj, nodeRef) {
-  const description = `[${nodeObj._id["brightCyan"]}] ${nodeObj._type._id}${nodeRef ? " - " + _optionalChain([nodeRef, 'optionalAccess', _691 => _691.displayName]) : ""}`;
+  const description = `[${nodeObj._id["brightCyan"]}] ${nodeObj._type._id}${nodeRef ? " - " + _optionalChain([nodeRef, 'optionalAccess', _701 => _701.displayName]) : ""}`;
   return description;
 }
 function getTableHeaderMd2() {
@@ -241432,7 +241629,7 @@ function getExtractedFiles(obj, connectorMappingDirectory) {
   if (!obj || typeof obj !== "object") return;
   for (const key of Object.keys(obj)) {
     const value = obj[key];
-    if (_optionalChain([value, 'optionalAccess', _692 => _692.type]) === "text/javascript" && value.file) {
+    if (_optionalChain([value, 'optionalAccess', _702 => _702.type]) === "text/javascript" && value.file) {
       const scriptPath = sysPath2.default.join(connectorMappingDirectory, value.file);
       if (fs52.default.existsSync(scriptPath)) {
         value.source = fs52.default.readFileSync(scriptPath, { encoding: "utf-8" });
@@ -242128,7 +242325,7 @@ function getExtractedFiles2(obj, managedObjectDirectory) {
   if (!obj || typeof obj !== "object") return;
   for (const key of Object.keys(obj)) {
     const value = obj[key];
-    if (_optionalChain([value, 'optionalAccess', _693 => _693.type]) === "text/javascript" && value.file) {
+    if (_optionalChain([value, 'optionalAccess', _703 => _703.type]) === "text/javascript" && value.file) {
       const scriptPath = sysPath2.default.join(managedObjectDirectory, value.file);
       if (fs52.default.existsSync(scriptPath)) {
         value.source = fs52.default.readFileSync(scriptPath, { encoding: "utf-8" });
@@ -242462,7 +242659,7 @@ async function configManagerImportPasswordPolicy(realm2) {
       if (parsedData && typeof parsedData === "object" && parsedData.idm && typeof parsedData.idm === "object" && Object.keys(parsedData.idm).length > 0) {
         importData = { idm: parsedData.idm };
       } else {
-        const id7 = _optionalChain([parsedData, 'optionalAccess', _694 => _694._id]);
+        const id7 = _optionalChain([parsedData, 'optionalAccess', _704 => _704._id]);
         if (!id7) {
           throw new Error(
             `Invalid password policy payload in '${filePath}': expected either an 'idm' map or top-level '_id'.`
@@ -242654,7 +242851,7 @@ async function configManagerImportSchedules(schedulesName) {
       if (schedulesName && id7 !== `schedule/${schedulesName}`) {
         continue;
       }
-      if (_optionalChain([importData, 'access', _695 => _695.invokeContext, 'optionalAccess', _696 => _696.task, 'optionalAccess', _697 => _697.script, 'optionalAccess', _698 => _698.file])) {
+      if (_optionalChain([importData, 'access', _705 => _705.invokeContext, 'optionalAccess', _706 => _706.task, 'optionalAccess', _707 => _707.script, 'optionalAccess', _708 => _708.file])) {
         const scriptPath = getFilePath39(
           `schedules/${schedulesFile}/${importData.invokeContext.task.script.file}`
         );
@@ -246778,7 +246975,7 @@ async function tailLogs(source, levels, txid, cookie, nf) {
       filteredLogs = logsObject.result.filter(
         (el) => !noiseFilter.includes(
           el.payload.logger
-        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _699 => _699.payload, 'access', _700 => _700.transactionId, 'optionalAccess', _701 => _701.includes, 'call', _702 => _702(
+        ) && !noiseFilter.includes(el.type) && (levels[0] === "ALL" || levels.includes(resolvePayloadLevel2(el))) && (typeof txid === "undefined" || txid === null || _optionalChain([el, 'access', _709 => _709.payload, 'access', _710 => _710.transactionId, 'optionalAccess', _711 => _711.includes, 'call', _712 => _712(
           txid
         )]))
       );
@@ -246995,9 +247192,9 @@ function setup148() {
                 `Created log API key ${creds.api_key_id} and secret.`
               );
             } catch (error49) {
-              printMessage2(_optionalChain([error49, 'access', _703 => _703.response, 'optionalAccess', _704 => _704.data]), "error");
+              printMessage2(_optionalChain([error49, 'access', _713 => _713.response, 'optionalAccess', _714 => _714.data]), "error");
               printMessage2(
-                `Error creating log API key and secret: ${_optionalChain([error49, 'access', _705 => _705.response, 'optionalAccess', _706 => _706.data, 'optionalAccess', _707 => _707.message])}`,
+                `Error creating log API key and secret: ${_optionalChain([error49, 'access', _715 => _715.response, 'optionalAccess', _716 => _716.data, 'optionalAccess', _717 => _717.message])}`,
                 "error"
               );
               process.exitCode = 1;
@@ -248128,7 +248325,7 @@ function setup162() {
           printMessage2(updatesTable.toString(), "data");
         }
         if (!options.checkOnly) {
-          if (_optionalChain([updates, 'access', _708 => _708.secrets, 'optionalAccess', _709 => _709.length]) || _optionalChain([updates, 'access', _710 => _710.variables, 'optionalAccess', _711 => _711.length]) || options.force) {
+          if (_optionalChain([updates, 'access', _718 => _718.secrets, 'optionalAccess', _719 => _719.length]) || _optionalChain([updates, 'access', _720 => _720.variables, 'optionalAccess', _721 => _721.length]) || options.force) {
             const ok = options.yes || await (0, import_yesno.default)({
               question: `
 Changes may take up to 10 minutes to propagate, during which time you will not be able to make further updates.
@@ -252612,18 +252809,18 @@ async function listJourneys(long = false) {
         0,
         `Retrieving details of all journeys...`
       );
-      const exportPromises = [];
       try {
-        for (const journeyStub of journeys) {
-          exportPromises.push(
-            exportJourney2(journeyStub["_id"], {
-              useStringArrays: false,
-              deps: false,
-              coords: true
-            })
-          );
-        }
-        const journeyExports = await Promise.all(exportPromises);
+        const journeyExportPromises = journeys.map((journeyStub) => ({
+          journeyId: journeyStub["_id"],
+          promise: exportJourney2(journeyStub["_id"], {
+            useStringArrays: false,
+            deps: false,
+            coords: true
+          })
+        }));
+        const journeyExports = await Promise.all(
+          journeyExportPromises.map((p) => p.promise)
+        );
         stopProgressIndicator2(
           spinnerId,
           "Retrieved details of all journeys.",
@@ -252639,17 +252836,25 @@ async function listJourneys(long = false) {
           "Resource",
           "Tags"
         ]);
-        for (const journeyExport of journeyExports) {
+        for (let i2 = 0; i2 < journeyExports.length; i2++) {
+          const { journeyId } = journeyExportPromises[i2];
+          const treeExport = journeyExports[i2].trees[journeyId];
+          if (!treeExport) {
+            debugMessage2(
+              `listJourneys: journey '${journeyId}' not found in export response, skipping`
+            );
+            continue;
+          }
           table.push([
-            `${journeyExport.tree._id}`,
-            journeyExport.tree.enabled === false ? "disabled"["brightRed"] : "enabled"["brightGreen"],
-            journeyExport.tree.innerTreeOnly ? "yes"["brightYellow"] : "no"["brightGreen"],
-            journeyExport.tree.mustRun ? "yes"["brightYellow"] : "no"["brightGreen"],
-            journeyExport.tree.noSession ? "yes"["brightYellow"] : "no"["brightGreen"],
-            journeyExport.tree.transactionalOnly ? "yes"["brightYellow"] : "no"["brightGreen"],
-            journeyExport.tree.identityResource ? journeyExport.tree.identityResource : "",
-            _optionalChain([journeyExport, 'access', _712 => _712.tree, 'access', _713 => _713.uiConfig, 'optionalAccess', _714 => _714.categories]) ? wordwrap(
-              JSON.parse(journeyExport.tree.uiConfig.categories).join(", "),
+            `${treeExport.tree._id}`,
+            treeExport.tree.enabled === false ? "disabled"["brightRed"] : "enabled"["brightGreen"],
+            treeExport.tree.innerTreeOnly ? "yes"["brightYellow"] : "no"["brightGreen"],
+            treeExport.tree.mustRun ? "yes"["brightYellow"] : "no"["brightGreen"],
+            treeExport.tree.noSession ? "yes"["brightYellow"] : "no"["brightGreen"],
+            treeExport.tree.transactionalOnly ? "yes"["brightYellow"] : "no"["brightGreen"],
+            treeExport.tree.identityResource ? treeExport.tree.identityResource : "",
+            _optionalChain([treeExport, 'access', _722 => _722.tree, 'access', _723 => _723.uiConfig, 'optionalAccess', _724 => _724.categories]) ? wordwrap(
+              JSON.parse(treeExport.tree.uiConfig.categories).join(", "),
               60
             ) : ""
           ]);
@@ -252692,11 +252897,7 @@ async function exportJourneyToFile(journeyId, file2, includeMeta = true, options
     delete fileData.meta;
     if (verbose)
       spinnerId = createProgressIndicator2("indeterminate", 0, `${journeyId}`);
-    saveJsonToFile57(
-      { trees: { [fileData.tree._id]: fileData } },
-      filePath,
-      includeMeta
-    );
+    saveJsonToFile57(fileData, filePath, includeMeta);
     stopProgressIndicator2(
       spinnerId,
       `Exported ${journeyId["brightCyan"]} to ${filePath["brightCyan"]}.`,
@@ -252964,11 +253165,11 @@ async function importJourneysFromFiles(options) {
     const allJourneysData = { trees: {} };
     for (const file2 of jsonFiles) {
       const fileObj = JSON.parse(fs52.default.readFileSync(file2, "utf8"));
-      if (_optionalChain([fileObj, 'optionalAccess', _715 => _715.trees]) && typeof fileObj.trees === "object") {
+      if (_optionalChain([fileObj, 'optionalAccess', _725 => _725.trees]) && typeof fileObj.trees === "object") {
         for (const [id7, obj] of Object.entries(fileObj.trees)) {
           allJourneysData.trees[id7] = obj;
         }
-      } else if (_optionalChain([fileObj, 'optionalAccess', _716 => _716.tree, 'optionalAccess', _717 => _717._id])) {
+      } else if (_optionalChain([fileObj, 'optionalAccess', _726 => _726.tree, 'optionalAccess', _727 => _727._id])) {
         allJourneysData.trees[fileObj.tree._id] = fileObj;
       } else {
         printMessage2(
@@ -253047,7 +253248,7 @@ async function describeJourney(journeyData, resolveTreeExport = onlineTreeExport
         nodeTypeMap[nodeData._type._id] = 1;
       }
     }
-    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _718 => _718.meta, 'optionalAccess', _719 => _719.originAmVersion])) {
+    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _728 => _728.meta, 'optionalAccess', _729 => _729.originAmVersion])) {
       state.setAmVersion(journeyData.meta.originAmVersion);
     }
     printMessage2(`${getOneLineDescription8(journeyData.tree)}`, "data");
@@ -253071,7 +253272,7 @@ Flags
 - No Session: ${journeyData.tree.noSession ? "true"["brightGreen"] : "false"["brightRed"]}
 - Transactional Only: ${journeyData.tree.transactionalOnly ? "true"["brightGreen"] : "false"["brightRed"]}`
     );
-    if (_optionalChain([journeyData, 'access', _720 => _720.tree, 'access', _721 => _721.uiConfig, 'optionalAccess', _722 => _722.categories]) && journeyData.tree.uiConfig.categories != "[]") {
+    if (_optionalChain([journeyData, 'access', _730 => _730.tree, 'access', _731 => _731.uiConfig, 'optionalAccess', _732 => _732.categories]) && journeyData.tree.uiConfig.categories != "[]") {
       printMessage2("\nCategories/Tags", "data");
       printMessage2(
         `${JSON.parse(journeyData.tree.uiConfig.categories).join(", ")}`,
@@ -253110,7 +253311,7 @@ Nodes (${Object.entries(allNodes).length}):`, "data");
         );
       }
     }
-    if (_optionalChain([journeyData, 'access', _723 => _723.themes, 'optionalAccess', _724 => _724.length])) {
+    if (_optionalChain([journeyData, 'access', _733 => _733.themes, 'optionalAccess', _734 => _734.length])) {
       printMessage2(`
 Themes (${journeyData.themes.length}):`, "data");
       for (const themeData of journeyData.themes) {
@@ -253204,14 +253405,14 @@ async function describeJourneyMd(journeyData, resolveTreeExport = onlineTreeExpo
         nodeTypeMap[nodeData._type._id] = 1;
       }
     }
-    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _725 => _725.meta, 'optionalAccess', _726 => _726.originAmVersion])) {
+    if (!state.getAmVersion() && _optionalChain([journeyData, 'access', _735 => _735.meta, 'optionalAccess', _736 => _736.originAmVersion])) {
       state.setAmVersion(journeyData.meta.originAmVersion);
     }
     printMessage2(
       `# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ":o: `disabled`" : ":white_check_mark: `enabled`"}, ${journeyData.tree.innerTreeOnly ? ":o: `innerTreeOnly`" : ":white_check_mark: `not innerTreeOnly`"}, ${journeyData.tree.mustRun ? ":o: `mustRun`" : ":white_check_mark: `not mustRun`"}, ${journeyData.tree.noSession ? ":o: `noSession`" : ":white_check_mark: `sessionAllowed`"}, ${journeyData.tree.transactionalOnly ? ":o: `transactionalOnly`" : ":white_check_mark: `not transactionalOnly`"}${journeyData.tree.identityResource ? `, identity resource: \`${journeyData.tree.identityResource}\`` : ""}`,
       "data"
     );
-    if (_optionalChain([journeyData, 'access', _727 => _727.tree, 'access', _728 => _728.uiConfig, 'optionalAccess', _729 => _729.categories]) && journeyData.tree.uiConfig.categories != "[]") {
+    if (_optionalChain([journeyData, 'access', _737 => _737.tree, 'access', _738 => _738.uiConfig, 'optionalAccess', _739 => _739.categories]) && journeyData.tree.uiConfig.categories != "[]") {
       printMessage2(
         `\`${JSON.parse(journeyData.tree.uiConfig.categories).join("`, `")}\``,
         "data"
@@ -253250,7 +253451,7 @@ ${journeyData.tree.description}`, "data");
         );
       }
     }
-    if (_optionalChain([journeyData, 'access', _730 => _730.themes, 'optionalAccess', _731 => _731.length])) {
+    if (_optionalChain([journeyData, 'access', _740 => _740.themes, 'optionalAccess', _741 => _741.length])) {
       printMessage2(`## Themes (${journeyData.themes.length})`, "data");
       printMessage2(getTableHeaderMd7(), "data");
       for (const themeData of journeyData.themes) {
@@ -253535,9 +253736,9 @@ function setup203() {
             journeyData = fileData.trees[options.journeyId];
           } else if (typeof options.journeyId === "undefined" && fileData.trees) {
             [journeyData] = Object.values(fileData.trees);
-          } else if (typeof options.journeyId !== "undefined" && options.journeyId === _optionalChain([fileData, 'access', _732 => _732.tree, 'optionalAccess', _733 => _733._id])) {
+          } else if (typeof options.journeyId !== "undefined" && options.journeyId === _optionalChain([fileData, 'access', _742 => _742.tree, 'optionalAccess', _743 => _743._id])) {
             journeyData = fileData;
-          } else if (typeof options.journeyId === "undefined" && _optionalChain([fileData, 'access', _734 => _734.tree, 'optionalAccess', _735 => _735._id])) {
+          } else if (typeof options.journeyId === "undefined" && _optionalChain([fileData, 'access', _744 => _744.tree, 'optionalAccess', _745 => _745._id])) {
             journeyData = fileData;
           } else {
             throw new Error(
@@ -253571,7 +253772,13 @@ function setup203() {
           journeys = await readJourneys3();
           for (const journey of journeys) {
             try {
-              const treeData = await exportJourney3(journey["_id"]);
+              const multiTreeData = await exportJourney3(journey["_id"]);
+              const treeData = multiTreeData.trees[journey["_id"]];
+              if (!treeData) {
+                throw new Error(
+                  `Journey '${journey["_id"]}' not found in export response`
+                );
+              }
               const originalAmVersion = state.getAmVersion();
               const runtimeResolver = async (treeId) => {
                 const resolverVersion = state.getAmVersion();
@@ -253611,7 +253818,13 @@ function setup203() {
           }
         } else {
           try {
-            const treeData = await exportJourney3(options.journeyId);
+            const multiTreeData = await exportJourney3(options.journeyId);
+            const treeData = multiTreeData.trees[options.journeyId];
+            if (!treeData) {
+              throw new Error(
+                `Journey '${options.journeyId}' not found in export response`
+              );
+            }
             const originalAmVersion = state.getAmVersion();
             const runtimeResolver = async (treeId) => {
               const resolverVersion = state.getAmVersion();
@@ -255369,7 +255582,7 @@ _chunkDLBJL7R2cjs.init_cjs_shims.call(void 0, );
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-  errorUtil2.toString = (message) => typeof message === "string" ? message : _optionalChain([message, 'optionalAccess', _736 => _736.message]);
+  errorUtil2.toString = (message) => typeof message === "string" ? message : _optionalChain([message, 'optionalAccess', _746 => _746.message]);
 })(errorUtil || (errorUtil = {}));
 
 // node_modules/zod/v3/types.js
@@ -255485,10 +255698,10 @@ var ZodType = class {
     const ctx = {
       common: {
         issues: [],
-        async: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _737 => _737.async]), () => ( false)),
-        contextualErrorMap: _optionalChain([params, 'optionalAccess', _738 => _738.errorMap])
+        async: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _747 => _747.async]), () => ( false)),
+        contextualErrorMap: _optionalChain([params, 'optionalAccess', _748 => _748.errorMap])
       },
-      path: _optionalChain([params, 'optionalAccess', _739 => _739.path]) || [],
+      path: _optionalChain([params, 'optionalAccess', _749 => _749.path]) || [],
       schemaErrorMap: this._def.errorMap,
       parent: null,
       data: data2,
@@ -255518,7 +255731,7 @@ var ZodType = class {
           issues: ctx.common.issues
         };
       } catch (err) {
-        if (_optionalChain([err, 'optionalAccess', _740 => _740.message, 'optionalAccess', _741 => _741.toLowerCase, 'call', _742 => _742(), 'optionalAccess', _743 => _743.includes, 'call', _744 => _744("encountered")])) {
+        if (_optionalChain([err, 'optionalAccess', _750 => _750.message, 'optionalAccess', _751 => _751.toLowerCase, 'call', _752 => _752(), 'optionalAccess', _753 => _753.includes, 'call', _754 => _754("encountered")])) {
           this["~standard"].async = true;
         }
         ctx.common = {
@@ -255543,10 +255756,10 @@ var ZodType = class {
     const ctx = {
       common: {
         issues: [],
-        contextualErrorMap: _optionalChain([params, 'optionalAccess', _745 => _745.errorMap]),
+        contextualErrorMap: _optionalChain([params, 'optionalAccess', _755 => _755.errorMap]),
         async: true
       },
-      path: _optionalChain([params, 'optionalAccess', _746 => _746.path]) || [],
+      path: _optionalChain([params, 'optionalAccess', _756 => _756.path]) || [],
       schemaErrorMap: this._def.errorMap,
       parent: null,
       data: data2,
@@ -255777,7 +255990,7 @@ function isValidJWT(jwt2, alg) {
     const decoded = JSON.parse(atob(base643));
     if (typeof decoded !== "object" || decoded === null)
       return false;
-    if ("typ" in decoded && _optionalChain([decoded, 'optionalAccess', _747 => _747.typ]) !== "JWT")
+    if ("typ" in decoded && _optionalChain([decoded, 'optionalAccess', _757 => _757.typ]) !== "JWT")
       return false;
     if (!decoded.alg)
       return false;
@@ -256166,10 +256379,10 @@ var ZodString = class _ZodString2 extends ZodType {
     }
     return this._addCheck({
       kind: "datetime",
-      precision: typeof _optionalChain([options, 'optionalAccess', _748 => _748.precision]) === "undefined" ? null : _optionalChain([options, 'optionalAccess', _749 => _749.precision]),
-      offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _750 => _750.offset]), () => ( false)),
-      local: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _751 => _751.local]), () => ( false)),
-      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _752 => _752.message]))
+      precision: typeof _optionalChain([options, 'optionalAccess', _758 => _758.precision]) === "undefined" ? null : _optionalChain([options, 'optionalAccess', _759 => _759.precision]),
+      offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _760 => _760.offset]), () => ( false)),
+      local: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _761 => _761.local]), () => ( false)),
+      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _762 => _762.message]))
     });
   }
   date(message) {
@@ -256185,8 +256398,8 @@ var ZodString = class _ZodString2 extends ZodType {
     }
     return this._addCheck({
       kind: "time",
-      precision: typeof _optionalChain([options, 'optionalAccess', _753 => _753.precision]) === "undefined" ? null : _optionalChain([options, 'optionalAccess', _754 => _754.precision]),
-      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _755 => _755.message]))
+      precision: typeof _optionalChain([options, 'optionalAccess', _763 => _763.precision]) === "undefined" ? null : _optionalChain([options, 'optionalAccess', _764 => _764.precision]),
+      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _765 => _765.message]))
     });
   }
   duration(message) {
@@ -256203,8 +256416,8 @@ var ZodString = class _ZodString2 extends ZodType {
     return this._addCheck({
       kind: "includes",
       value,
-      position: _optionalChain([options, 'optionalAccess', _756 => _756.position]),
-      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _757 => _757.message]))
+      position: _optionalChain([options, 'optionalAccess', _766 => _766.position]),
+      ...errorUtil.errToObj(_optionalChain([options, 'optionalAccess', _767 => _767.message]))
     });
   }
   startsWith(value, message) {
@@ -256339,7 +256552,7 @@ ZodString.create = (params) => {
   return new ZodString({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodString,
-    coerce: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _758 => _758.coerce]), () => ( false)),
+    coerce: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _768 => _768.coerce]), () => ( false)),
     ...processCreateParams(params)
   });
 };
@@ -256579,7 +256792,7 @@ ZodNumber.create = (params) => {
   return new ZodNumber({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodNumber,
-    coerce: _optionalChain([params, 'optionalAccess', _759 => _759.coerce]) || false,
+    coerce: _optionalChain([params, 'optionalAccess', _769 => _769.coerce]) || false,
     ...processCreateParams(params)
   });
 };
@@ -256751,7 +256964,7 @@ ZodBigInt.create = (params) => {
   return new ZodBigInt({
     checks: [],
     typeName: ZodFirstPartyTypeKind.ZodBigInt,
-    coerce: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _760 => _760.coerce]), () => ( false)),
+    coerce: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _770 => _770.coerce]), () => ( false)),
     ...processCreateParams(params)
   });
 };
@@ -256776,7 +256989,7 @@ var ZodBoolean = class extends ZodType {
 ZodBoolean.create = (params) => {
   return new ZodBoolean({
     typeName: ZodFirstPartyTypeKind.ZodBoolean,
-    coerce: _optionalChain([params, 'optionalAccess', _761 => _761.coerce]) || false,
+    coerce: _optionalChain([params, 'optionalAccess', _771 => _771.coerce]) || false,
     ...processCreateParams(params)
   });
 };
@@ -256884,7 +257097,7 @@ var ZodDate = class _ZodDate extends ZodType {
 ZodDate.create = (params) => {
   return new ZodDate({
     checks: [],
-    coerce: _optionalChain([params, 'optionalAccess', _762 => _762.coerce]) || false,
+    coerce: _optionalChain([params, 'optionalAccess', _772 => _772.coerce]) || false,
     typeName: ZodFirstPartyTypeKind.ZodDate,
     ...processCreateParams(params)
   });
@@ -257258,7 +257471,7 @@ var ZodObject = class _ZodObject extends ZodType {
       unknownKeys: "strict",
       ...message !== void 0 ? {
         errorMap: (issue2, ctx) => {
-          const defaultError = _nullishCoalesce(_optionalChain([this, 'access', _763 => _763._def, 'access', _764 => _764.errorMap, 'optionalCall', _765 => _765(issue2, ctx), 'access', _766 => _766.message]), () => ( ctx.defaultError));
+          const defaultError = _nullishCoalesce(_optionalChain([this, 'access', _773 => _773._def, 'access', _774 => _774.errorMap, 'optionalCall', _775 => _775(issue2, ctx), 'access', _776 => _776.message]), () => ( ctx.defaultError));
           if (issue2.code === "unrecognized_keys")
             return {
               message: _nullishCoalesce(errorUtil.errToObj(message).message, () => ( defaultError))
@@ -259092,13 +259305,13 @@ function $constructor(name, initializer3, params) {
       }
     }
   }
-  const Parent = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _767 => _767.Parent]), () => ( Object));
+  const Parent = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _777 => _777.Parent]), () => ( Object));
   class Definition extends Parent {
   }
   Object.defineProperty(Definition, "name", { value: name });
   function _(def7) {
     var _a4;
-    const inst = _optionalChain([params, 'optionalAccess', _768 => _768.Parent]) ? new Definition() : this;
+    const inst = _optionalChain([params, 'optionalAccess', _778 => _778.Parent]) ? new Definition() : this;
     init(inst, def7);
     _nullishCoalesce((_a4 = inst._zod).deferred, () => ( (_a4.deferred = [])));
     for (const fn of inst._zod.deferred) {
@@ -259109,9 +259322,9 @@ function $constructor(name, initializer3, params) {
   Object.defineProperty(_, "init", { value: init });
   Object.defineProperty(_, Symbol.hasInstance, {
     value: (inst) => {
-      if (_optionalChain([params, 'optionalAccess', _769 => _769.Parent]) && inst instanceof params.Parent)
+      if (_optionalChain([params, 'optionalAccess', _779 => _779.Parent]) && inst instanceof params.Parent)
         return true;
-      return _optionalChain([inst, 'optionalAccess', _770 => _770._zod, 'optionalAccess', _771 => _771.traits, 'optionalAccess', _772 => _772.has, 'call', _773 => _773(name)]);
+      return _optionalChain([inst, 'optionalAccess', _780 => _780._zod, 'optionalAccess', _781 => _781.traits, 'optionalAccess', _782 => _782.has, 'call', _783 => _783(name)]);
     }
   });
   Object.defineProperty(_, "name", { value: name });
@@ -259262,7 +259475,7 @@ function floatSafeRemainder2(val, step2) {
   let stepDecCount = (stepString.split(".")[1] || "").length;
   if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
     const match2 = stepString.match(/\d?e-(\d?)/);
-    if (_optionalChain([match2, 'optionalAccess', _774 => _774[1]])) {
+    if (_optionalChain([match2, 'optionalAccess', _784 => _784[1]])) {
       stepDecCount = Number.parseInt(match2[1]);
     }
   }
@@ -259319,7 +259532,7 @@ function cloneDef(schema) {
 function getElementAtPath(obj, path16) {
   if (!path16)
     return obj;
-  return path16.reduce((acc, key) => _optionalChain([acc, 'optionalAccess', _775 => _775[key]]), obj);
+  return path16.reduce((acc, key) => _optionalChain([acc, 'optionalAccess', _785 => _785[key]]), obj);
 }
 function promiseAllObject(promisesObj) {
   const keys13 = Object.keys(promisesObj);
@@ -259352,7 +259565,7 @@ function isObject5(data2) {
   return typeof data2 === "object" && data2 !== null && !Array.isArray(data2);
 }
 var allowsEval = cached(() => {
-  if (typeof navigator !== "undefined" && _optionalChain([navigator, 'optionalAccess', _776 => _776.userAgent, 'optionalAccess', _777 => _777.includes, 'call', _778 => _778("Cloudflare")])) {
+  if (typeof navigator !== "undefined" && _optionalChain([navigator, 'optionalAccess', _786 => _786.userAgent, 'optionalAccess', _787 => _787.includes, 'call', _788 => _788("Cloudflare")])) {
     return false;
   }
   try {
@@ -259446,7 +259659,7 @@ function escapeRegex2(str) {
 }
 function clone(inst, def7, params) {
   const cl = new inst._zod.constr(_nullishCoalesce(def7, () => ( inst._zod.def)));
-  if (!def7 || _optionalChain([params, 'optionalAccess', _779 => _779.parent]))
+  if (!def7 || _optionalChain([params, 'optionalAccess', _789 => _789.parent]))
     cl._zod.parent = inst;
   return cl;
 }
@@ -259456,8 +259669,8 @@ function normalizeParams(_params) {
     return {};
   if (typeof params === "string")
     return { error: () => params };
-  if (_optionalChain([params, 'optionalAccess', _780 => _780.message]) !== void 0) {
-    if (_optionalChain([params, 'optionalAccess', _781 => _781.error]) !== void 0)
+  if (_optionalChain([params, 'optionalAccess', _790 => _790.message]) !== void 0) {
+    if (_optionalChain([params, 'optionalAccess', _791 => _791.error]) !== void 0)
       throw new Error("Cannot specify both `message` and `error` params");
     params.error = params.message;
   }
@@ -259696,7 +259909,7 @@ function aborted(x, startIndex = 0) {
   if (x.aborted === true)
     return true;
   for (let i2 = startIndex; i2 < x.issues.length; i2++) {
-    if (_optionalChain([x, 'access', _782 => _782.issues, 'access', _783 => _783[i2], 'optionalAccess', _784 => _784.continue]) !== true) {
+    if (_optionalChain([x, 'access', _792 => _792.issues, 'access', _793 => _793[i2], 'optionalAccess', _794 => _794.continue]) !== true) {
       return true;
     }
   }
@@ -259711,17 +259924,17 @@ function prefixIssues(path16, issues) {
   });
 }
 function unwrapMessage(message) {
-  return typeof message === "string" ? message : _optionalChain([message, 'optionalAccess', _785 => _785.message]);
+  return typeof message === "string" ? message : _optionalChain([message, 'optionalAccess', _795 => _795.message]);
 }
 function finalizeIssue(iss, ctx, config5) {
   const full = { ...iss, path: _nullishCoalesce(iss.path, () => ( [])) };
   if (!iss.message) {
-    const message = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(unwrapMessage(_optionalChain([iss, 'access', _786 => _786.inst, 'optionalAccess', _787 => _787._zod, 'access', _788 => _788.def, 'optionalAccess', _789 => _789.error, 'optionalCall', _790 => _790(iss)])), () => ( unwrapMessage(_optionalChain([ctx, 'optionalAccess', _791 => _791.error, 'optionalCall', _792 => _792(iss)])))), () => ( unwrapMessage(_optionalChain([config5, 'access', _793 => _793.customError, 'optionalCall', _794 => _794(iss)])))), () => ( unwrapMessage(_optionalChain([config5, 'access', _795 => _795.localeError, 'optionalCall', _796 => _796(iss)])))), () => ( "Invalid input"));
+    const message = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(unwrapMessage(_optionalChain([iss, 'access', _796 => _796.inst, 'optionalAccess', _797 => _797._zod, 'access', _798 => _798.def, 'optionalAccess', _799 => _799.error, 'optionalCall', _800 => _800(iss)])), () => ( unwrapMessage(_optionalChain([ctx, 'optionalAccess', _801 => _801.error, 'optionalCall', _802 => _802(iss)])))), () => ( unwrapMessage(_optionalChain([config5, 'access', _803 => _803.customError, 'optionalCall', _804 => _804(iss)])))), () => ( unwrapMessage(_optionalChain([config5, 'access', _805 => _805.localeError, 'optionalCall', _806 => _806(iss)])))), () => ( "Invalid input"));
     full.message = message;
   }
   delete full.inst;
   delete full.continue;
-  if (!_optionalChain([ctx, 'optionalAccess', _797 => _797.reportInput])) {
+  if (!_optionalChain([ctx, 'optionalAccess', _807 => _807.reportInput])) {
     delete full.input;
   }
   return full;
@@ -259952,7 +260165,7 @@ function prettifyError(error49) {
   const issues = [...error49.issues].sort((a, b) => (_nullishCoalesce(a.path, () => ( []))).length - (_nullishCoalesce(b.path, () => ( []))).length);
   for (const issue2 of issues) {
     lines.push(`\u2716 ${issue2.message}`);
-    if (_optionalChain([issue2, 'access', _798 => _798.path, 'optionalAccess', _799 => _799.length]))
+    if (_optionalChain([issue2, 'access', _808 => _808.path, 'optionalAccess', _809 => _809.length]))
       lines.push(`  \u2192 at ${toDotPath(issue2.path)}`);
   }
   return lines.join("\n");
@@ -259966,8 +260179,8 @@ var _parse = (_Err) => (schema, value, _ctx7, _params) => {
     throw new $ZodAsyncError();
   }
   if (result.issues.length) {
-    const e = new (_nullishCoalesce(_optionalChain([_params, 'optionalAccess', _800 => _800.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
-    captureStackTrace(e, _optionalChain([_params, 'optionalAccess', _801 => _801.callee]));
+    const e = new (_nullishCoalesce(_optionalChain([_params, 'optionalAccess', _810 => _810.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
+    captureStackTrace(e, _optionalChain([_params, 'optionalAccess', _811 => _811.callee]));
     throw e;
   }
   return result.value;
@@ -259979,8 +260192,8 @@ var _parseAsync = (_Err) => async (schema, value, _ctx7, params) => {
   if (result instanceof Promise)
     result = await result;
   if (result.issues.length) {
-    const e = new (_nullishCoalesce(_optionalChain([params, 'optionalAccess', _802 => _802.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
-    captureStackTrace(e, _optionalChain([params, 'optionalAccess', _803 => _803.callee]));
+    const e = new (_nullishCoalesce(_optionalChain([params, 'optionalAccess', _812 => _812.Err]), () => ( _Err)))(result.issues.map((iss) => finalizeIssue(iss, ctx, config4())));
+    captureStackTrace(e, _optionalChain([params, 'optionalAccess', _813 => _813.callee]));
     throw e;
   }
   return result.value;
@@ -260176,7 +260389,7 @@ function datetime(args) {
   return new RegExp(`^${dateSource}T(?:${timeRegex2})$`);
 }
 var string = (params) => {
-  const regex2 = params ? `[\\s\\S]{${_nullishCoalesce(_optionalChain([params, 'optionalAccess', _804 => _804.minimum]), () => ( 0))},${_nullishCoalesce(_optionalChain([params, 'optionalAccess', _805 => _805.maximum]), () => ( ""))}}` : `[\\s\\S]*`;
+  const regex2 = params ? `[\\s\\S]{${_nullishCoalesce(_optionalChain([params, 'optionalAccess', _814 => _814.minimum]), () => ( 0))},${_nullishCoalesce(_optionalChain([params, 'optionalAccess', _815 => _815.maximum]), () => ( ""))}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex2}$`);
 };
 var bigint = /^-?\d+n?$/;
@@ -260303,7 +260516,7 @@ var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (i
 var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def7) => {
   $ZodCheck.init(inst, def7);
   def7.format = def7.format || "float64";
-  const isInt = _optionalChain([def7, 'access', _806 => _806.format, 'optionalAccess', _807 => _807.includes, 'call', _808 => _808("int")]);
+  const isInt = _optionalChain([def7, 'access', _816 => _816.format, 'optionalAccess', _817 => _817.includes, 'call', _818 => _818("int")]);
   const origin2 = isInt ? "int" : "number";
   const [minimum, maximum] = NUMBER_FORMAT_RANGES[def7.format];
   inst._zod.onattach.push((inst2) => {
@@ -260788,8 +261001,8 @@ var Doc = class {
   }
   compile() {
     const F = Function;
-    const args = _optionalChain([this, 'optionalAccess', _809 => _809.args]);
-    const content = _nullishCoalesce(_optionalChain([this, 'optionalAccess', _810 => _810.content]), () => ( [``]));
+    const args = _optionalChain([this, 'optionalAccess', _819 => _819.args]);
+    const content = _nullishCoalesce(_optionalChain([this, 'optionalAccess', _820 => _820.content]), () => ( [``]));
     const lines = [...content.map((x) => `  ${x}`)];
     return new F(...args, lines.join("\n"));
   }
@@ -260821,7 +261034,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def7) => {
   }
   if (checks.length === 0) {
     _nullishCoalesce((_a4 = inst._zod).deferred, () => ( (_a4.deferred = [])));
-    _optionalChain([inst, 'access', _811 => _811._zod, 'access', _812 => _812.deferred, 'optionalAccess', _813 => _813.push, 'call', _814 => _814(() => {
+    _optionalChain([inst, 'access', _821 => _821._zod, 'access', _822 => _822.deferred, 'optionalAccess', _823 => _823.push, 'call', _824 => _824(() => {
       inst._zod.run = inst._zod.parse;
     })]);
   } else {
@@ -260838,7 +261051,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def7) => {
         }
         const currLen = payload.issues.length;
         const _ = ch._zod.check(payload);
-        if (_ instanceof Promise && _optionalChain([ctx, 'optionalAccess', _815 => _815.async]) === false) {
+        if (_ instanceof Promise && _optionalChain([ctx, 'optionalAccess', _825 => _825.async]) === false) {
           throw new $ZodAsyncError();
         }
         if (asyncResult || _ instanceof Promise) {
@@ -260904,9 +261117,9 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def7) => {
     validate: (value) => {
       try {
         const r = safeParse(inst, value);
-        return r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _816 => _816.error, 'optionalAccess', _817 => _817.issues]) };
+        return r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _826 => _826.error, 'optionalAccess', _827 => _827.issues]) };
       } catch (_) {
-        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _818 => _818.error, 'optionalAccess', _819 => _819.issues]) });
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: _optionalChain([r, 'access', _828 => _828.error, 'optionalAccess', _829 => _829.issues]) });
       }
     },
     vendor: "zod",
@@ -260915,7 +261128,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def7) => {
 });
 var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def7) => {
   $ZodType.init(inst, def7);
-  inst._zod.pattern = _nullishCoalesce([..._nullishCoalesce(_optionalChain([inst, 'optionalAccess', _820 => _820._zod, 'access', _821 => _821.bag, 'optionalAccess', _822 => _822.patterns]), () => ( []))].pop(), () => ( string(inst._zod.bag)));
+  inst._zod.pattern = _nullishCoalesce([..._nullishCoalesce(_optionalChain([inst, 'optionalAccess', _830 => _830._zod, 'access', _831 => _831.bag, 'optionalAccess', _832 => _832.patterns]), () => ( []))].pop(), () => ( string(inst._zod.bag)));
   inst._zod.parse = (payload, _) => {
     if (def7.coerce)
       try {
@@ -261184,7 +261397,7 @@ function isValidJWT2(token2, algorithm = null) {
     if (!header)
       return false;
     const parsedHeader = JSON.parse(atob(header));
-    if ("typ" in parsedHeader && _optionalChain([parsedHeader, 'optionalAccess', _823 => _823.typ]) !== "JWT")
+    if ("typ" in parsedHeader && _optionalChain([parsedHeader, 'optionalAccess', _833 => _833.typ]) !== "JWT")
       return false;
     if (!parsedHeader.alg)
       return false;
@@ -261463,7 +261676,7 @@ function handlePropertyResult(result, final, key, input, isOptionalOut) {
 function normalizeDef(def7) {
   const keys13 = Object.keys(def7.shape);
   for (const k2 of keys13) {
-    if (!_optionalChain([def7, 'access', _824 => _824.shape, 'optionalAccess', _825 => _825[k2], 'optionalAccess', _826 => _826._zod, 'optionalAccess', _827 => _827.traits, 'optionalAccess', _828 => _828.has, 'call', _829 => _829("$ZodType")])) {
+    if (!_optionalChain([def7, 'access', _834 => _834.shape, 'optionalAccess', _835 => _835[k2], 'optionalAccess', _836 => _836._zod, 'optionalAccess', _837 => _837.traits, 'optionalAccess', _838 => _838.has, 'call', _839 => _839("$ZodType")])) {
       throw new Error(`Invalid element at key "${k2}": expected a Zod schema`);
     }
   }
@@ -261513,7 +261726,7 @@ function handleCatchall(proms, input, payload, ctx, def7, inst) {
 var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def7) => {
   $ZodType.init(inst, def7);
   const desc = Object.getOwnPropertyDescriptor(def7, "shape");
-  if (!_optionalChain([desc, 'optionalAccess', _830 => _830.get])) {
+  if (!_optionalChain([desc, 'optionalAccess', _840 => _840.get])) {
     const sh = def7.shape;
     Object.defineProperty(def7, "shape", {
       get: () => {
@@ -261595,7 +261808,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def7) =
       const id7 = ids[key];
       const k2 = esc(key);
       const schema = shape[key];
-      const isOptionalOut = _optionalChain([schema, 'optionalAccess', _831 => _831._zod, 'optionalAccess', _832 => _832.optout]) === "optional";
+      const isOptionalOut = _optionalChain([schema, 'optionalAccess', _841 => _841._zod, 'optionalAccess', _842 => _842.optout]) === "optional";
       doc.write(`const ${id7} = ${parseStr(key)};`);
       if (isOptionalOut) {
         doc.write(`
@@ -261661,7 +261874,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def7) =
       });
       return payload;
     }
-    if (jit && fastEnabled && _optionalChain([ctx, 'optionalAccess', _833 => _833.async]) === false && ctx.jitless !== true) {
+    if (jit && fastEnabled && _optionalChain([ctx, 'optionalAccess', _843 => _843.async]) === false && ctx.jitless !== true) {
       if (!fastpass)
         fastpass = generateFastpass(def7.shape);
       payload = fastpass(payload, ctx);
@@ -261816,7 +262029,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
     const opts = def7.options;
     const map5 = /* @__PURE__ */ new Map();
     for (const o of opts) {
-      const values3 = _optionalChain([o, 'access', _834 => _834._zod, 'access', _835 => _835.propValues, 'optionalAccess', _836 => _836[def7.discriminator]]);
+      const values3 = _optionalChain([o, 'access', _844 => _844._zod, 'access', _845 => _845.propValues, 'optionalAccess', _846 => _846[def7.discriminator]]);
       if (!values3 || values3.size === 0)
         throw new Error(`Invalid discriminated union option at index "${def7.options.indexOf(o)}"`);
       for (const v of values3) {
@@ -261839,7 +262052,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       });
       return payload;
     }
-    const opt = disc.value.get(_optionalChain([input, 'optionalAccess', _837 => _837[def7.discriminator]]));
+    const opt = disc.value.get(_optionalChain([input, 'optionalAccess', _847 => _847[def7.discriminator]]));
     if (opt) {
       return opt._zod.run(payload, ctx);
     }
@@ -262583,8 +262796,8 @@ var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def7) =>
   $ZodType.init(inst, def7);
   defineLazy(inst._zod, "propValues", () => def7.innerType._zod.propValues);
   defineLazy(inst._zod, "values", () => def7.innerType._zod.values);
-  defineLazy(inst._zod, "optin", () => _optionalChain([def7, 'access', _838 => _838.innerType, 'optionalAccess', _839 => _839._zod, 'optionalAccess', _840 => _840.optin]));
-  defineLazy(inst._zod, "optout", () => _optionalChain([def7, 'access', _841 => _841.innerType, 'optionalAccess', _842 => _842._zod, 'optionalAccess', _843 => _843.optout]));
+  defineLazy(inst._zod, "optin", () => _optionalChain([def7, 'access', _848 => _848.innerType, 'optionalAccess', _849 => _849._zod, 'optionalAccess', _850 => _850.optin]));
+  defineLazy(inst._zod, "optout", () => _optionalChain([def7, 'access', _851 => _851.innerType, 'optionalAccess', _852 => _852._zod, 'optionalAccess', _853 => _853.optout]));
   inst._zod.parse = (payload, ctx) => {
     if (ctx.direction === "backward") {
       return def7.innerType._zod.run(payload, ctx);
@@ -262731,10 +262944,10 @@ var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def7) => {
 var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def7) => {
   $ZodType.init(inst, def7);
   defineLazy(inst._zod, "innerType", () => def7.getter());
-  defineLazy(inst._zod, "pattern", () => _optionalChain([inst, 'access', _844 => _844._zod, 'access', _845 => _845.innerType, 'optionalAccess', _846 => _846._zod, 'optionalAccess', _847 => _847.pattern]));
-  defineLazy(inst._zod, "propValues", () => _optionalChain([inst, 'access', _848 => _848._zod, 'access', _849 => _849.innerType, 'optionalAccess', _850 => _850._zod, 'optionalAccess', _851 => _851.propValues]));
-  defineLazy(inst._zod, "optin", () => _nullishCoalesce(_optionalChain([inst, 'access', _852 => _852._zod, 'access', _853 => _853.innerType, 'optionalAccess', _854 => _854._zod, 'optionalAccess', _855 => _855.optin]), () => ( void 0)));
-  defineLazy(inst._zod, "optout", () => _nullishCoalesce(_optionalChain([inst, 'access', _856 => _856._zod, 'access', _857 => _857.innerType, 'optionalAccess', _858 => _858._zod, 'optionalAccess', _859 => _859.optout]), () => ( void 0)));
+  defineLazy(inst._zod, "pattern", () => _optionalChain([inst, 'access', _854 => _854._zod, 'access', _855 => _855.innerType, 'optionalAccess', _856 => _856._zod, 'optionalAccess', _857 => _857.pattern]));
+  defineLazy(inst._zod, "propValues", () => _optionalChain([inst, 'access', _858 => _858._zod, 'access', _859 => _859.innerType, 'optionalAccess', _860 => _860._zod, 'optionalAccess', _861 => _861.propValues]));
+  defineLazy(inst._zod, "optin", () => _nullishCoalesce(_optionalChain([inst, 'access', _862 => _862._zod, 'access', _863 => _863.innerType, 'optionalAccess', _864 => _864._zod, 'optionalAccess', _865 => _865.optin]), () => ( void 0)));
+  defineLazy(inst._zod, "optout", () => _nullishCoalesce(_optionalChain([inst, 'access', _866 => _866._zod, 'access', _867 => _867.innerType, 'optionalAccess', _868 => _868._zod, 'optionalAccess', _869 => _869.optout]), () => ( void 0)));
   inst._zod.parse = (payload, ctx) => {
     const inner = inst._zod.innerType;
     return inner._zod.run(payload, ctx);
@@ -264619,7 +264832,7 @@ var error17 = () => {
   const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
   const verbFor = (t) => {
     const e = typeEntry(t);
-    const gender = _nullishCoalesce(_optionalChain([e, 'optionalAccess', _860 => _860.gender]), () => ( "m"));
+    const gender = _nullishCoalesce(_optionalChain([e, 'optionalAccess', _870 => _870.gender]), () => ( "m"));
     return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
   };
   const getSizing = (origin2) => {
@@ -264668,7 +264881,7 @@ var error17 = () => {
         const expectedKey = issue2.expected;
         const expected = _nullishCoalesce(TypeDictionary[_nullishCoalesce(expectedKey, () => ( ""))], () => ( typeLabel(expectedKey)));
         const receivedType = parsedType(issue2.input);
-        const received = _nullishCoalesce(_nullishCoalesce(TypeDictionary[receivedType], () => ( _optionalChain([TypeNames, 'access', _861 => _861[receivedType], 'optionalAccess', _862 => _862.label]))), () => ( receivedType));
+        const received = _nullishCoalesce(_nullishCoalesce(TypeDictionary[receivedType], () => ( _optionalChain([TypeNames, 'access', _871 => _871[receivedType], 'optionalAccess', _872 => _872.label]))), () => ( receivedType));
         if (/^[A-Z]/.test(issue2.expected)) {
           return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue2.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
         }
@@ -264690,7 +264903,7 @@ var error17 = () => {
         const sizing = getSizing(issue2.origin);
         const subject = withDefinite(_nullishCoalesce(issue2.origin, () => ( "value")));
         if (issue2.origin === "string") {
-          return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _863 => _863.longLabel]), () => ( "\u05D0\u05E8\u05D5\u05DA"))} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.maximum.toString()} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _864 => _864.unit]), () => ( ""))} ${issue2.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
+          return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _873 => _873.longLabel]), () => ( "\u05D0\u05E8\u05D5\u05DA"))} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.maximum.toString()} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _874 => _874.unit]), () => ( ""))} ${issue2.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
         }
         if (issue2.origin === "number") {
           const comparison = issue2.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue2.maximum}`;
@@ -264698,21 +264911,21 @@ var error17 = () => {
         }
         if (issue2.origin === "array" || issue2.origin === "set") {
           const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
-          const comparison = issue2.inclusive ? `${issue2.maximum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _865 => _865.unit]), () => ( ""))} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue2.maximum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _866 => _866.unit]), () => ( ""))}`;
+          const comparison = issue2.inclusive ? `${issue2.maximum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _875 => _875.unit]), () => ( ""))} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue2.maximum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _876 => _876.unit]), () => ( ""))}`;
           return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? "<=" : "<";
         const be = verbFor(_nullishCoalesce(issue2.origin, () => ( "value")));
-        if (_optionalChain([sizing, 'optionalAccess', _867 => _867.unit])) {
+        if (_optionalChain([sizing, 'optionalAccess', _877 => _877.unit])) {
           return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
         }
-        return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _868 => _868.longLabel]), () => ( "\u05D2\u05D3\u05D5\u05DC"))} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
+        return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _878 => _878.longLabel]), () => ( "\u05D2\u05D3\u05D5\u05DC"))} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
       }
       case "too_small": {
         const sizing = getSizing(issue2.origin);
         const subject = withDefinite(_nullishCoalesce(issue2.origin, () => ( "value")));
         if (issue2.origin === "string") {
-          return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _869 => _869.shortLabel]), () => ( "\u05E7\u05E6\u05E8"))} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.minimum.toString()} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _870 => _870.unit]), () => ( ""))} ${issue2.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
+          return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _879 => _879.shortLabel]), () => ( "\u05E7\u05E6\u05E8"))} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.minimum.toString()} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _880 => _880.unit]), () => ( ""))} ${issue2.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
         }
         if (issue2.origin === "number") {
           const comparison = issue2.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue2.minimum}`;
@@ -264724,15 +264937,15 @@ var error17 = () => {
             const singularPhrase = issue2.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
             return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
           }
-          const comparison = issue2.inclusive ? `${issue2.minimum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _871 => _871.unit]), () => ( ""))} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue2.minimum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _872 => _872.unit]), () => ( ""))}`;
+          const comparison = issue2.inclusive ? `${issue2.minimum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _881 => _881.unit]), () => ( ""))} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue2.minimum} ${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _882 => _882.unit]), () => ( ""))}`;
           return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? ">=" : ">";
         const be = verbFor(_nullishCoalesce(issue2.origin, () => ( "value")));
-        if (_optionalChain([sizing, 'optionalAccess', _873 => _873.unit])) {
+        if (_optionalChain([sizing, 'optionalAccess', _883 => _883.unit])) {
           return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
         }
-        return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _874 => _874.shortLabel]), () => ( "\u05E7\u05D8\u05DF"))} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
+        return `${_nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _884 => _884.shortLabel]), () => ( "\u05E7\u05D8\u05DF"))} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue2;
@@ -264745,8 +264958,8 @@ var error17 = () => {
         if (_issue.format === "regex")
           return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
         const nounEntry = FormatDictionary[_issue.format];
-        const noun = _nullishCoalesce(_optionalChain([nounEntry, 'optionalAccess', _875 => _875.label]), () => ( _issue.format));
-        const gender = _nullishCoalesce(_optionalChain([nounEntry, 'optionalAccess', _876 => _876.gender]), () => ( "m"));
+        const noun = _nullishCoalesce(_optionalChain([nounEntry, 'optionalAccess', _885 => _885.label]), () => ( _issue.format));
+        const gender = _nullishCoalesce(_optionalChain([nounEntry, 'optionalAccess', _886 => _886.gender]), () => ( "m"));
         const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
         return `${noun} \u05DC\u05D0 ${adjective}`;
       }
@@ -265769,7 +265982,7 @@ var error26 = () => {
         const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
         const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
         const sizing = getSizing(issue2.origin);
-        const unit = _nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _877 => _877.unit]), () => ( "\uC694\uC18C"));
+        const unit = _nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _887 => _887.unit]), () => ( "\uC694\uC18C"));
         if (sizing)
           return `${_nullishCoalesce(issue2.origin, () => ( "\uAC12"))}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;
         return `${_nullishCoalesce(issue2.origin, () => ( "\uAC12"))}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`;
@@ -265778,7 +265991,7 @@ var error26 = () => {
         const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
         const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
         const sizing = getSizing(issue2.origin);
-        const unit = _nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _878 => _878.unit]), () => ( "\uC694\uC18C"));
+        const unit = _nullishCoalesce(_optionalChain([sizing, 'optionalAccess', _888 => _888.unit]), () => ( "\uC694\uC18C"));
         if (sizing) {
           return `${_nullishCoalesce(issue2.origin, () => ( "\uAC12"))}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;
         }
@@ -265974,18 +266187,18 @@ var error27 = () => {
       case "too_big": {
         const origin2 = _nullishCoalesce(TypeDictionary[issue2.origin], () => ( issue2.origin));
         const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), _nullishCoalesce(issue2.inclusive, () => ( false)), "smaller");
-        if (_optionalChain([sizing, 'optionalAccess', _879 => _879.verb]))
+        if (_optionalChain([sizing, 'optionalAccess', _889 => _889.verb]))
           return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} ${sizing.verb} ${issue2.maximum.toString()} ${_nullishCoalesce(sizing.unit, () => ( "element\u0173"))}`;
         const adj = issue2.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
-        return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${_optionalChain([sizing, 'optionalAccess', _880 => _880.unit])}`;
+        return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${_optionalChain([sizing, 'optionalAccess', _890 => _890.unit])}`;
       }
       case "too_small": {
         const origin2 = _nullishCoalesce(TypeDictionary[issue2.origin], () => ( issue2.origin));
         const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), _nullishCoalesce(issue2.inclusive, () => ( false)), "bigger");
-        if (_optionalChain([sizing, 'optionalAccess', _881 => _881.verb]))
+        if (_optionalChain([sizing, 'optionalAccess', _891 => _891.verb]))
           return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} ${sizing.verb} ${issue2.minimum.toString()} ${_nullishCoalesce(sizing.unit, () => ( "element\u0173"))}`;
         const adj = issue2.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
-        return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} turi b\u016Bti ${adj} ${issue2.minimum.toString()} ${_optionalChain([sizing, 'optionalAccess', _882 => _882.unit])}`;
+        return `${capitalizeFirstCharacter(_nullishCoalesce(_nullishCoalesce(origin2, () => ( issue2.origin)), () => ( "reik\u0161m\u0117")))} turi b\u016Bti ${adj} ${issue2.minimum.toString()} ${_optionalChain([sizing, 'optionalAccess', _892 => _892.unit])}`;
       }
       case "invalid_format": {
         const _issue = issue2;
@@ -269499,24 +269712,24 @@ function _stringFormat(Class2, format2, fnOrRegex, _params = {}) {
 // node_modules/zod/v4/core/to-json-schema.js
 _chunkDLBJL7R2cjs.init_cjs_shims.call(void 0, );
 function initializeContext(params) {
-  let target = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _883 => _883.target]), () => ( "draft-2020-12"));
+  let target = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _893 => _893.target]), () => ( "draft-2020-12"));
   if (target === "draft-4")
     target = "draft-04";
   if (target === "draft-7")
     target = "draft-07";
   return {
     processors: _nullishCoalesce(params.processors, () => ( {})),
-    metadataRegistry: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _884 => _884.metadata]), () => ( globalRegistry)),
+    metadataRegistry: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _894 => _894.metadata]), () => ( globalRegistry)),
     target,
-    unrepresentable: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _885 => _885.unrepresentable]), () => ( "throw")),
-    override: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _886 => _886.override]), () => ( (() => {
+    unrepresentable: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _895 => _895.unrepresentable]), () => ( "throw")),
+    override: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _896 => _896.override]), () => ( (() => {
     }))),
-    io: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _887 => _887.io]), () => ( "output")),
+    io: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _897 => _897.io]), () => ( "output")),
     counter: 0,
     seen: /* @__PURE__ */ new Map(),
-    cycles: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _888 => _888.cycles]), () => ( "ref")),
-    reused: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _889 => _889.reused]), () => ( "inline")),
-    external: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _890 => _890.external]), () => ( void 0))
+    cycles: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _898 => _898.cycles]), () => ( "ref")),
+    reused: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _899 => _899.reused]), () => ( "inline")),
+    external: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _900 => _900.external]), () => ( void 0))
   };
 }
 function process5(schema, ctx, _params = { path: [], schemaPath: [] }) {
@@ -269533,7 +269746,7 @@ function process5(schema, ctx, _params = { path: [], schemaPath: [] }) {
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
   ctx.seen.set(schema, result);
-  const overrideSchema = _optionalChain([schema, 'access', _891 => _891._zod, 'access', _892 => _892.toJSONSchema, 'optionalCall', _893 => _893()]);
+  const overrideSchema = _optionalChain([schema, 'access', _901 => _901._zod, 'access', _902 => _902.toJSONSchema, 'optionalCall', _903 => _903()]);
   if (overrideSchema) {
     result.schema = overrideSchema;
   } else {
@@ -269579,7 +269792,7 @@ function extractDefs(ctx, schema) {
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
   for (const entry of ctx.seen.entries()) {
-    const id7 = _optionalChain([ctx, 'access', _894 => _894.metadataRegistry, 'access', _895 => _895.get, 'call', _896 => _896(entry[0]), 'optionalAccess', _897 => _897.id]);
+    const id7 = _optionalChain([ctx, 'access', _904 => _904.metadataRegistry, 'access', _905 => _905.get, 'call', _906 => _906(entry[0]), 'optionalAccess', _907 => _907.id]);
     if (id7) {
       const existing = idToSchema.get(id7);
       if (existing && existing !== entry[0]) {
@@ -269591,7 +269804,7 @@ function extractDefs(ctx, schema) {
   const makeURI = (entry) => {
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
     if (ctx.external) {
-      const externalId = _optionalChain([ctx, 'access', _898 => _898.external, 'access', _899 => _899.registry, 'access', _900 => _900.get, 'call', _901 => _901(entry[0]), 'optionalAccess', _902 => _902.id]);
+      const externalId = _optionalChain([ctx, 'access', _908 => _908.external, 'access', _909 => _909.registry, 'access', _910 => _910.get, 'call', _911 => _911(entry[0]), 'optionalAccess', _912 => _912.id]);
       const uriGenerator = _nullishCoalesce(ctx.external.uri, () => ( ((id8) => id8)));
       if (externalId) {
         return { ref: uriGenerator(externalId) };
@@ -269627,7 +269840,7 @@ function extractDefs(ctx, schema) {
     for (const entry of ctx.seen.entries()) {
       const seen = entry[1];
       if (seen.cycle) {
-        throw new Error(`Cycle detected: #/${_optionalChain([seen, 'access', _903 => _903.cycle, 'optionalAccess', _904 => _904.join, 'call', _905 => _905("/")])}/<root>
+        throw new Error(`Cycle detected: #/${_optionalChain([seen, 'access', _913 => _913.cycle, 'optionalAccess', _914 => _914.join, 'call', _915 => _915("/")])}/<root>
 
 Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
       }
@@ -269640,13 +269853,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       continue;
     }
     if (ctx.external) {
-      const ext = _optionalChain([ctx, 'access', _906 => _906.external, 'access', _907 => _907.registry, 'access', _908 => _908.get, 'call', _909 => _909(entry[0]), 'optionalAccess', _910 => _910.id]);
+      const ext = _optionalChain([ctx, 'access', _916 => _916.external, 'access', _917 => _917.registry, 'access', _918 => _918.get, 'call', _919 => _919(entry[0]), 'optionalAccess', _920 => _920.id]);
       if (schema !== entry[0] && ext) {
         extractToDef(entry);
         continue;
       }
     }
-    const id7 = _optionalChain([ctx, 'access', _911 => _911.metadataRegistry, 'access', _912 => _912.get, 'call', _913 => _913(entry[0]), 'optionalAccess', _914 => _914.id]);
+    const id7 = _optionalChain([ctx, 'access', _921 => _921.metadataRegistry, 'access', _922 => _922.get, 'call', _923 => _923(entry[0]), 'optionalAccess', _924 => _924.id]);
     if (id7) {
       extractToDef(entry);
       continue;
@@ -269710,7 +269923,7 @@ function finalize(ctx, schema) {
     if (parent && parent !== ref) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
-      if (_optionalChain([parentSeen, 'optionalAccess', _915 => _915.schema, 'access', _916 => _916.$ref])) {
+      if (_optionalChain([parentSeen, 'optionalAccess', _925 => _925.schema, 'access', _926 => _926.$ref])) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
           for (const key in schema2) {
@@ -269742,14 +269955,14 @@ function finalize(ctx, schema) {
   } else if (ctx.target === "openapi-3.0") {
   } else {
   }
-  if (_optionalChain([ctx, 'access', _917 => _917.external, 'optionalAccess', _918 => _918.uri])) {
-    const id7 = _optionalChain([ctx, 'access', _919 => _919.external, 'access', _920 => _920.registry, 'access', _921 => _921.get, 'call', _922 => _922(schema), 'optionalAccess', _923 => _923.id]);
+  if (_optionalChain([ctx, 'access', _927 => _927.external, 'optionalAccess', _928 => _928.uri])) {
+    const id7 = _optionalChain([ctx, 'access', _929 => _929.external, 'access', _930 => _930.registry, 'access', _931 => _931.get, 'call', _932 => _932(schema), 'optionalAccess', _933 => _933.id]);
     if (!id7)
       throw new Error("Schema is missing an `id` property");
     result.$id = ctx.external.uri(id7);
   }
   Object.assign(result, _nullishCoalesce(root4.def, () => ( root4.schema)));
-  const defs = _nullishCoalesce(_optionalChain([ctx, 'access', _924 => _924.external, 'optionalAccess', _925 => _925.defs]), () => ( {}));
+  const defs = _nullishCoalesce(_optionalChain([ctx, 'access', _934 => _934.external, 'optionalAccess', _935 => _935.defs]), () => ( {}));
   for (const entry of ctx.seen.entries()) {
     const seen = entry[1];
     if (seen.def && seen.defId) {
@@ -270128,7 +270341,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   if (requiredKeys.size > 0) {
     json2.required = Array.from(requiredKeys);
   }
-  if (_optionalChain([def7, 'access', _926 => _926.catchall, 'optionalAccess', _927 => _927._zod, 'access', _928 => _928.def, 'access', _929 => _929.type]) === "never") {
+  if (_optionalChain([def7, 'access', _936 => _936.catchall, 'optionalAccess', _937 => _937._zod, 'access', _938 => _938.def, 'access', _939 => _939.type]) === "never") {
     json2.additionalProperties = false;
   } else if (!def7.catchall) {
     if (ctx.io === "output")
@@ -270218,7 +270431,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   json2.type = "object";
   const keyType = def7.keyType;
   const keyBag = keyType._zod.bag;
-  const patterns = _optionalChain([keyBag, 'optionalAccess', _930 => _930.patterns]);
+  const patterns = _optionalChain([keyBag, 'optionalAccess', _940 => _940.patterns]);
   if (def7.mode === "loose" && patterns && patterns.size > 0) {
     const valueSchema = process5(def7.valueType, ctx, {
       ...params,
@@ -270378,7 +270591,7 @@ function toJSONSchema(input, params) {
     const schemas = {};
     const external = {
       registry: registry2,
-      uri: _optionalChain([params, 'optionalAccess', _931 => _931.uri]),
+      uri: _optionalChain([params, 'optionalAccess', _941 => _941.uri]),
       defs
     };
     ctx2.external = external;
@@ -270436,7 +270649,7 @@ var JSONSchemaGenerator = class {
     return this.ctx.seen;
   }
   constructor(params) {
-    let normalizedTarget = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _932 => _932.target]), () => ( "draft-2020-12"));
+    let normalizedTarget = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _942 => _942.target]), () => ( "draft-2020-12"));
     if (normalizedTarget === "draft-4")
       normalizedTarget = "draft-04";
     if (normalizedTarget === "draft-7")
@@ -270444,10 +270657,10 @@ var JSONSchemaGenerator = class {
     this.ctx = initializeContext({
       processors: allProcessors,
       target: normalizedTarget,
-      ..._optionalChain([params, 'optionalAccess', _933 => _933.metadata]) && { metadata: params.metadata },
-      ..._optionalChain([params, 'optionalAccess', _934 => _934.unrepresentable]) && { unrepresentable: params.unrepresentable },
-      ..._optionalChain([params, 'optionalAccess', _935 => _935.override]) && { override: params.override },
-      ..._optionalChain([params, 'optionalAccess', _936 => _936.io]) && { io: params.io }
+      ..._optionalChain([params, 'optionalAccess', _943 => _943.metadata]) && { metadata: params.metadata },
+      ..._optionalChain([params, 'optionalAccess', _944 => _944.unrepresentable]) && { unrepresentable: params.unrepresentable },
+      ..._optionalChain([params, 'optionalAccess', _945 => _945.override]) && { override: params.override },
+      ..._optionalChain([params, 'optionalAccess', _946 => _946.io]) && { io: params.io }
     });
   }
   /**
@@ -270579,7 +270792,7 @@ function getObjectShape(schema) {
   let rawShape;
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
-    rawShape = _optionalChain([v4Schema, 'access', _937 => _937._zod, 'optionalAccess', _938 => _938.def, 'optionalAccess', _939 => _939.shape]);
+    rawShape = _optionalChain([v4Schema, 'access', _947 => _947._zod, 'optionalAccess', _948 => _948.def, 'optionalAccess', _949 => _949.shape]);
   } else {
     const v3Schema = schema;
     rawShape = v3Schema.shape;
@@ -270610,7 +270823,7 @@ function normalizeObjectSchema(schema) {
   }
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
-    const def7 = _optionalChain([v4Schema, 'access', _940 => _940._zod, 'optionalAccess', _941 => _941.def]);
+    const def7 = _optionalChain([v4Schema, 'access', _950 => _950._zod, 'optionalAccess', _951 => _951.def]);
     if (def7 && (def7.type === "object" || def7.shape !== void 0)) {
       return schema;
     }
@@ -270647,18 +270860,18 @@ function getSchemaDescription(schema) {
 function isSchemaOptional(schema) {
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
-    return _optionalChain([v4Schema, 'access', _942 => _942._zod, 'optionalAccess', _943 => _943.def, 'optionalAccess', _944 => _944.type]) === "optional";
+    return _optionalChain([v4Schema, 'access', _952 => _952._zod, 'optionalAccess', _953 => _953.def, 'optionalAccess', _954 => _954.type]) === "optional";
   }
   const v3Schema = schema;
   if (typeof schema.isOptional === "function") {
     return schema.isOptional();
   }
-  return _optionalChain([v3Schema, 'access', _945 => _945._def, 'optionalAccess', _946 => _946.typeName]) === "ZodOptional";
+  return _optionalChain([v3Schema, 'access', _955 => _955._def, 'optionalAccess', _956 => _956.typeName]) === "ZodOptional";
 }
 function getLiteralValue(schema) {
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
-    const def8 = _optionalChain([v4Schema, 'access', _947 => _947._zod, 'optionalAccess', _948 => _948.def]);
+    const def8 = _optionalChain([v4Schema, 'access', _957 => _957._zod, 'optionalAccess', _958 => _958.def]);
     if (def8) {
       if (def8.value !== void 0)
         return def8.value;
@@ -271305,7 +271518,7 @@ var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def7) => {
   };
   Object.defineProperty(inst, "description", {
     get() {
-      return _optionalChain([globalRegistry, 'access', _949 => _949.get, 'call', _950 => _950(inst), 'optionalAccess', _951 => _951.description]);
+      return _optionalChain([globalRegistry, 'access', _959 => _959.get, 'call', _960 => _960(inst), 'optionalAccess', _961 => _961.description]);
     },
     configurable: true
   });
@@ -271554,7 +271767,7 @@ function hex5(_params) {
   return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
 }
 function hash(alg, params) {
-  const enc2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _952 => _952.enc]), () => ( "hex"));
+  const enc2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _962 => _962.enc]), () => ( "hex"));
   const format2 = `${alg}_${enc2}`;
   const regex2 = regexes_exports[format2];
   if (!regex2)
@@ -272252,8 +272465,8 @@ var ZodFunction2 = /* @__PURE__ */ $constructor("ZodFunction", (inst, def7) => {
 function _function(params) {
   return new ZodFunction2({
     type: "function",
-    input: Array.isArray(_optionalChain([params, 'optionalAccess', _953 => _953.input])) ? tuple(_optionalChain([params, 'optionalAccess', _954 => _954.input])) : _nullishCoalesce(_optionalChain([params, 'optionalAccess', _955 => _955.input]), () => ( array(unknown()))),
-    output: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _956 => _956.output]), () => ( unknown()))
+    input: Array.isArray(_optionalChain([params, 'optionalAccess', _963 => _963.input])) ? tuple(_optionalChain([params, 'optionalAccess', _964 => _964.input])) : _nullishCoalesce(_optionalChain([params, 'optionalAccess', _965 => _965.input]), () => ( array(unknown()))),
+    output: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _966 => _966.output]), () => ( unknown()))
   });
 }
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def7) => {
@@ -272806,7 +273019,7 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  const version4 = detectVersion(schema, _optionalChain([params, 'optionalAccess', _957 => _957.defaultTarget]));
+  const version4 = detectVersion(schema, _optionalChain([params, 'optionalAccess', _967 => _967.defaultTarget]));
   const defs = schema.$defs || schema.definitions || {};
   const ctx = {
     version: version4,
@@ -272814,7 +273027,7 @@ function fromJSONSchema(schema, params) {
     refs: /* @__PURE__ */ new Map(),
     processing: /* @__PURE__ */ new Set(),
     rootSchema: schema,
-    registry: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _958 => _958.registry]), () => ( globalRegistry))
+    registry: _nullishCoalesce(_optionalChain([params, 'optionalAccess', _968 => _968.registry]), () => ( globalRegistry))
   };
   return convertSchema(schema, ctx);
 }
@@ -274377,7 +274590,7 @@ var UrlElicitationRequiredError = class extends McpError {
     });
   }
   get elicitations() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _959 => _959.data, 'optionalAccess', _960 => _960.elicitations]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _969 => _969.data, 'optionalAccess', _970 => _970.elicitations]), () => ( []));
   }
 };
 
@@ -274453,7 +274666,7 @@ var getRefs = (options) => {
 // node_modules/zod-to-json-schema/dist/esm/errorMessages.js
 _chunkDLBJL7R2cjs.init_cjs_shims.call(void 0, );
 function addErrorMessage(res, key, errorMessage, refs) {
-  if (!_optionalChain([refs, 'optionalAccess', _961 => _961.errorMessages]))
+  if (!_optionalChain([refs, 'optionalAccess', _971 => _971.errorMessages]))
     return;
   if (errorMessage) {
     res.errorMessage = {
@@ -274507,7 +274720,7 @@ function parseArrayDef(def7, refs) {
   const res = {
     type: "array"
   };
-  if (_optionalChain([def7, 'access', _962 => _962.type, 'optionalAccess', _963 => _963._def]) && _optionalChain([def7, 'access', _964 => _964.type, 'optionalAccess', _965 => _965._def, 'optionalAccess', _966 => _966.typeName]) !== ZodFirstPartyTypeKind.ZodAny) {
+  if (_optionalChain([def7, 'access', _972 => _972.type, 'optionalAccess', _973 => _973._def]) && _optionalChain([def7, 'access', _974 => _974.type, 'optionalAccess', _975 => _975._def, 'optionalAccess', _976 => _976.typeName]) !== ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def7.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -274942,7 +275155,7 @@ function escapeNonAlphaNumeric(source) {
   return result;
 }
 function addFormat(schema, value, message, refs) {
-  if (schema.format || _optionalChain([schema, 'access', _967 => _967.anyOf, 'optionalAccess', _968 => _968.some, 'call', _969 => _969((x) => x.format)])) {
+  if (schema.format || _optionalChain([schema, 'access', _977 => _977.anyOf, 'optionalAccess', _978 => _978.some, 'call', _979 => _979((x) => x.format)])) {
     if (!schema.anyOf) {
       schema.anyOf = [];
     }
@@ -274970,7 +275183,7 @@ function addFormat(schema, value, message, refs) {
   }
 }
 function addPattern(schema, regex2, message, refs) {
-  if (schema.pattern || _optionalChain([schema, 'access', _970 => _970.allOf, 'optionalAccess', _971 => _971.some, 'call', _972 => _972((x) => x.pattern)])) {
+  if (schema.pattern || _optionalChain([schema, 'access', _980 => _980.allOf, 'optionalAccess', _981 => _981.some, 'call', _982 => _982((x) => x.pattern)])) {
     if (!schema.allOf) {
       schema.allOf = [];
     }
@@ -275025,7 +275238,7 @@ function stringifyRegExpWithFlags(regex2, refs) {
             pattern += source[i2];
             pattern += `${source[i2 - 2]}-${source[i2]}`.toUpperCase();
             inCharRange = false;
-          } else if (source[i2 + 1] === "-" && _optionalChain([source, 'access', _973 => _973[i2 + 2], 'optionalAccess', _974 => _974.match, 'call', _975 => _975(/[a-z]/)])) {
+          } else if (source[i2 + 1] === "-" && _optionalChain([source, 'access', _983 => _983[i2 + 2], 'optionalAccess', _984 => _984.match, 'call', _985 => _985(/[a-z]/)])) {
             pattern += source[i2];
             inCharRange = true;
           } else {
@@ -275078,7 +275291,7 @@ function parseRecordDef(def7, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && _optionalChain([def7, 'access', _976 => _976.keyType, 'optionalAccess', _977 => _977._def, 'access', _978 => _978.typeName]) === ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && _optionalChain([def7, 'access', _986 => _986.keyType, 'optionalAccess', _987 => _987._def, 'access', _988 => _988.typeName]) === ZodFirstPartyTypeKind.ZodEnum) {
     return {
       type: "object",
       required: def7.keyType._def.values,
@@ -275102,20 +275315,20 @@ function parseRecordDef(def7, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (_optionalChain([def7, 'access', _979 => _979.keyType, 'optionalAccess', _980 => _980._def, 'access', _981 => _981.typeName]) === ZodFirstPartyTypeKind.ZodString && _optionalChain([def7, 'access', _982 => _982.keyType, 'access', _983 => _983._def, 'access', _984 => _984.checks, 'optionalAccess', _985 => _985.length])) {
+  if (_optionalChain([def7, 'access', _989 => _989.keyType, 'optionalAccess', _990 => _990._def, 'access', _991 => _991.typeName]) === ZodFirstPartyTypeKind.ZodString && _optionalChain([def7, 'access', _992 => _992.keyType, 'access', _993 => _993._def, 'access', _994 => _994.checks, 'optionalAccess', _995 => _995.length])) {
     const { type, ...keyType } = parseStringDef(def7.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (_optionalChain([def7, 'access', _986 => _986.keyType, 'optionalAccess', _987 => _987._def, 'access', _988 => _988.typeName]) === ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (_optionalChain([def7, 'access', _996 => _996.keyType, 'optionalAccess', _997 => _997._def, 'access', _998 => _998.typeName]) === ZodFirstPartyTypeKind.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def7.keyType._def.values
       }
     };
-  } else if (_optionalChain([def7, 'access', _989 => _989.keyType, 'optionalAccess', _990 => _990._def, 'access', _991 => _991.typeName]) === ZodFirstPartyTypeKind.ZodBranded && def7.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && _optionalChain([def7, 'access', _992 => _992.keyType, 'access', _993 => _993._def, 'access', _994 => _994.type, 'access', _995 => _995._def, 'access', _996 => _996.checks, 'optionalAccess', _997 => _997.length])) {
+  } else if (_optionalChain([def7, 'access', _999 => _999.keyType, 'optionalAccess', _1000 => _1000._def, 'access', _1001 => _1001.typeName]) === ZodFirstPartyTypeKind.ZodBranded && def7.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && _optionalChain([def7, 'access', _1002 => _1002.keyType, 'access', _1003 => _1003._def, 'access', _1004 => _1004.type, 'access', _1005 => _1005._def, 'access', _1006 => _1006.checks, 'optionalAccess', _1007 => _1007.length])) {
     const { type, ...keyType } = parseBrandedDef(def7.keyType._def, refs);
     return {
       ...schema,
@@ -275415,7 +275628,7 @@ function safeIsOptional(schema) {
 // node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
 _chunkDLBJL7R2cjs.init_cjs_shims.call(void 0, );
 var parseOptionalDef = (def7, refs) => {
-  if (refs.currentPath.toString() === _optionalChain([refs, 'access', _998 => _998.propertyPath, 'optionalAccess', _999 => _999.toString, 'call', _1000 => _1000()])) {
+  if (refs.currentPath.toString() === _optionalChain([refs, 'access', _1008 => _1008.propertyPath, 'optionalAccess', _1009 => _1009.toString, 'call', _1010 => _1010()])) {
     return parseDef(def7.innerType._def, refs);
   }
   const innerSchema = parseDef(def7.innerType._def, {
@@ -275609,7 +275822,7 @@ var selectParser = (def7, typeName, refs) => {
 function parseDef(def7, refs, forceResolution = false) {
   const seenItem = refs.seen.get(def7);
   if (refs.override) {
-    const overrideResult = _optionalChain([refs, 'access', _1001 => _1001.override, 'optionalCall', _1002 => _1002(def7, refs, seenItem, forceResolution)]);
+    const overrideResult = _optionalChain([refs, 'access', _1011 => _1011.override, 'optionalCall', _1012 => _1012(def7, refs, seenItem, forceResolution)]);
     if (overrideResult !== ignoreOverride) {
       return overrideResult;
     }
@@ -275675,7 +275888,7 @@ var zodToJsonSchema = (schema, options) => {
       currentPath: [...refs.basePath, refs.definitionPath, name2]
     }, true), () => ( parseAnyDef(refs)))
   }), {}) : void 0;
-  const name = typeof options === "string" ? options : _optionalChain([options, 'optionalAccess', _1003 => _1003.nameStrategy]) === "title" ? void 0 : _optionalChain([options, 'optionalAccess', _1004 => _1004.name]);
+  const name = typeof options === "string" ? options : _optionalChain([options, 'optionalAccess', _1013 => _1013.nameStrategy]) === "title" ? void 0 : _optionalChain([options, 'optionalAccess', _1014 => _1014.name]);
   const main = _nullishCoalesce(parseDef(schema._def, name === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
@@ -275740,18 +275953,18 @@ function mapMiniTarget(t) {
 function toJsonSchemaCompat(schema, opts) {
   if (isZ4Schema(schema)) {
     return toJSONSchema(schema, {
-      target: mapMiniTarget(_optionalChain([opts, 'optionalAccess', _1005 => _1005.target])),
-      io: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1006 => _1006.pipeStrategy]), () => ( "input"))
+      target: mapMiniTarget(_optionalChain([opts, 'optionalAccess', _1015 => _1015.target])),
+      io: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1016 => _1016.pipeStrategy]), () => ( "input"))
     });
   }
   return zodToJsonSchema(schema, {
-    strictUnions: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1007 => _1007.strictUnions]), () => ( true)),
-    pipeStrategy: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1008 => _1008.pipeStrategy]), () => ( "input"))
+    strictUnions: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1017 => _1017.strictUnions]), () => ( true)),
+    pipeStrategy: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _1018 => _1018.pipeStrategy]), () => ( "input"))
   });
 }
 function getMethodLiteral(schema) {
   const shape = getObjectShape(schema);
-  const methodSchema = _optionalChain([shape, 'optionalAccess', _1009 => _1009.method]);
+  const methodSchema = _optionalChain([shape, 'optionalAccess', _1019 => _1019.method]);
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
   }
@@ -275795,8 +276008,8 @@ var Protocol = class {
       // Automatic pong by default.
       (_request) => ({})
     );
-    this._taskStore = _optionalChain([_options, 'optionalAccess', _1010 => _1010.taskStore]);
-    this._taskMessageQueue = _optionalChain([_options, 'optionalAccess', _1011 => _1011.taskMessageQueue]);
+    this._taskStore = _optionalChain([_options, 'optionalAccess', _1020 => _1020.taskStore]);
+    this._taskMessageQueue = _optionalChain([_options, 'optionalAccess', _1021 => _1021.taskMessageQueue]);
     if (this._taskStore) {
       this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
         const task5 = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
@@ -275832,7 +276045,7 @@ var Protocol = class {
                 }
                 continue;
               }
-              await _optionalChain([this, 'access', _1012 => _1012._transport, 'optionalAccess', _1013 => _1013.send, 'call', _1014 => _1014(queuedMessage.message, { relatedRequestId: extra.requestId })]);
+              await _optionalChain([this, 'access', _1022 => _1022._transport, 'optionalAccess', _1023 => _1023.send, 'call', _1024 => _1024(queuedMessage.message, { relatedRequestId: extra.requestId })]);
             }
           }
           const task5 = await this._taskStore.getTask(taskId, extra.sessionId);
@@ -275862,7 +276075,7 @@ var Protocol = class {
       });
       this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
         try {
-          const { tasks, nextCursor } = await this._taskStore.listTasks(_optionalChain([request, 'access', _1015 => _1015.params, 'optionalAccess', _1016 => _1016.cursor]), extra.sessionId);
+          const { tasks, nextCursor } = await this._taskStore.listTasks(_optionalChain([request, 'access', _1025 => _1025.params, 'optionalAccess', _1026 => _1026.cursor]), extra.sessionId);
           return {
             tasks,
             nextCursor,
@@ -275905,7 +276118,7 @@ var Protocol = class {
       return;
     }
     const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-    _optionalChain([controller, 'optionalAccess', _1017 => _1017.abort, 'call', _1018 => _1018(notification.params.reason)]);
+    _optionalChain([controller, 'optionalAccess', _1027 => _1027.abort, 'call', _1028 => _1028(notification.params.reason)]);
   }
   _setupTimeout(messageId, timeout4, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
     this._timeoutInfo.set(messageId, {
@@ -275950,19 +276163,19 @@ var Protocol = class {
       throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
     }
     this._transport = transport;
-    const _onclose = _optionalChain([this, 'access', _1019 => _1019.transport, 'optionalAccess', _1020 => _1020.onclose]);
+    const _onclose = _optionalChain([this, 'access', _1029 => _1029.transport, 'optionalAccess', _1030 => _1030.onclose]);
     this._transport.onclose = () => {
-      _optionalChain([_onclose, 'optionalCall', _1021 => _1021()]);
+      _optionalChain([_onclose, 'optionalCall', _1031 => _1031()]);
       this._onclose();
     };
-    const _onerror = _optionalChain([this, 'access', _1022 => _1022.transport, 'optionalAccess', _1023 => _1023.onerror]);
+    const _onerror = _optionalChain([this, 'access', _1032 => _1032.transport, 'optionalAccess', _1033 => _1033.onerror]);
     this._transport.onerror = (error49) => {
-      _optionalChain([_onerror, 'optionalCall', _1024 => _1024(error49)]);
+      _optionalChain([_onerror, 'optionalCall', _1034 => _1034(error49)]);
       this._onerror(error49);
     };
-    const _onmessage = _optionalChain([this, 'access', _1025 => _1025._transport, 'optionalAccess', _1026 => _1026.onmessage]);
+    const _onmessage = _optionalChain([this, 'access', _1035 => _1035._transport, 'optionalAccess', _1036 => _1036.onmessage]);
     this._transport.onmessage = (message, extra) => {
-      _optionalChain([_onmessage, 'optionalCall', _1027 => _1027(message, extra)]);
+      _optionalChain([_onmessage, 'optionalCall', _1037 => _1037(message, extra)]);
       if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
         this._onresponse(message);
       } else if (isJSONRPCRequest(message)) {
@@ -275991,13 +276204,13 @@ var Protocol = class {
     this._requestHandlerAbortControllers.clear();
     const error49 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     this._transport = void 0;
-    _optionalChain([this, 'access', _1028 => _1028.onclose, 'optionalCall', _1029 => _1029()]);
+    _optionalChain([this, 'access', _1038 => _1038.onclose, 'optionalCall', _1039 => _1039()]);
     for (const handler of responseHandlers.values()) {
       handler(error49);
     }
   }
   _onerror(error49) {
-    _optionalChain([this, 'access', _1030 => _1030.onerror, 'optionalCall', _1031 => _1031(error49)]);
+    _optionalChain([this, 'access', _1040 => _1040.onerror, 'optionalCall', _1041 => _1041(error49)]);
   }
   _onnotification(notification) {
     const handler = _nullishCoalesce(this._notificationHandlers.get(notification.method), () => ( this.fallbackNotificationHandler));
@@ -276009,7 +276222,7 @@ var Protocol = class {
   _onrequest(request, extra) {
     const handler = _nullishCoalesce(this._requestHandlers.get(request.method), () => ( this.fallbackRequestHandler));
     const capturedTransport = this._transport;
-    const relatedTaskId = _optionalChain([request, 'access', _1032 => _1032.params, 'optionalAccess', _1033 => _1033._meta, 'optionalAccess', _1034 => _1034[RELATED_TASK_META_KEY], 'optionalAccess', _1035 => _1035.taskId]);
+    const relatedTaskId = _optionalChain([request, 'access', _1042 => _1042.params, 'optionalAccess', _1043 => _1043._meta, 'optionalAccess', _1044 => _1044[RELATED_TASK_META_KEY], 'optionalAccess', _1045 => _1045.taskId]);
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -276024,20 +276237,20 @@ var Protocol = class {
           type: "error",
           message: errorResponse,
           timestamp: Date.now()
-        }, _optionalChain([capturedTransport, 'optionalAccess', _1036 => _1036.sessionId])).catch((error49) => this._onerror(new Error(`Failed to enqueue error response: ${error49}`)));
+        }, _optionalChain([capturedTransport, 'optionalAccess', _1046 => _1046.sessionId])).catch((error49) => this._onerror(new Error(`Failed to enqueue error response: ${error49}`)));
       } else {
-        _optionalChain([capturedTransport, 'optionalAccess', _1037 => _1037.send, 'call', _1038 => _1038(errorResponse), 'access', _1039 => _1039.catch, 'call', _1040 => _1040((error49) => this._onerror(new Error(`Failed to send an error response: ${error49}`)))]);
+        _optionalChain([capturedTransport, 'optionalAccess', _1047 => _1047.send, 'call', _1048 => _1048(errorResponse), 'access', _1049 => _1049.catch, 'call', _1050 => _1050((error49) => this._onerror(new Error(`Failed to send an error response: ${error49}`)))]);
       }
       return;
     }
     const abortController = new AbortController();
     this._requestHandlerAbortControllers.set(request.id, abortController);
     const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
-    const taskStore = this._taskStore ? this.requestTaskStore(request, _optionalChain([capturedTransport, 'optionalAccess', _1041 => _1041.sessionId])) : void 0;
+    const taskStore = this._taskStore ? this.requestTaskStore(request, _optionalChain([capturedTransport, 'optionalAccess', _1051 => _1051.sessionId])) : void 0;
     const fullExtra = {
       signal: abortController.signal,
-      sessionId: _optionalChain([capturedTransport, 'optionalAccess', _1042 => _1042.sessionId]),
-      _meta: _optionalChain([request, 'access', _1043 => _1043.params, 'optionalAccess', _1044 => _1044._meta]),
+      sessionId: _optionalChain([capturedTransport, 'optionalAccess', _1052 => _1052.sessionId]),
+      _meta: _optionalChain([request, 'access', _1053 => _1053.params, 'optionalAccess', _1054 => _1054._meta]),
       sendNotification: async (notification) => {
         if (abortController.signal.aborted)
           return;
@@ -276055,20 +276268,20 @@ var Protocol = class {
         if (relatedTaskId && !requestOptions.relatedTask) {
           requestOptions.relatedTask = { taskId: relatedTaskId };
         }
-        const effectiveTaskId = _nullishCoalesce(_optionalChain([requestOptions, 'access', _1045 => _1045.relatedTask, 'optionalAccess', _1046 => _1046.taskId]), () => ( relatedTaskId));
+        const effectiveTaskId = _nullishCoalesce(_optionalChain([requestOptions, 'access', _1055 => _1055.relatedTask, 'optionalAccess', _1056 => _1056.taskId]), () => ( relatedTaskId));
         if (effectiveTaskId && taskStore) {
           await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
         }
         return await this.request(r, resultSchema, requestOptions);
       },
-      authInfo: _optionalChain([extra, 'optionalAccess', _1047 => _1047.authInfo]),
+      authInfo: _optionalChain([extra, 'optionalAccess', _1057 => _1057.authInfo]),
       requestId: request.id,
-      requestInfo: _optionalChain([extra, 'optionalAccess', _1048 => _1048.requestInfo]),
+      requestInfo: _optionalChain([extra, 'optionalAccess', _1058 => _1058.requestInfo]),
       taskId: relatedTaskId,
       taskStore,
-      taskRequestedTtl: _optionalChain([taskCreationParams, 'optionalAccess', _1049 => _1049.ttl]),
-      closeSSEStream: _optionalChain([extra, 'optionalAccess', _1050 => _1050.closeSSEStream]),
-      closeStandaloneSSEStream: _optionalChain([extra, 'optionalAccess', _1051 => _1051.closeStandaloneSSEStream])
+      taskRequestedTtl: _optionalChain([taskCreationParams, 'optionalAccess', _1059 => _1059.ttl]),
+      closeSSEStream: _optionalChain([extra, 'optionalAccess', _1060 => _1060.closeSSEStream]),
+      closeStandaloneSSEStream: _optionalChain([extra, 'optionalAccess', _1061 => _1061.closeStandaloneSSEStream])
     };
     Promise.resolve().then(() => {
       if (taskCreationParams) {
@@ -276088,9 +276301,9 @@ var Protocol = class {
           type: "response",
           message: response,
           timestamp: Date.now()
-        }, _optionalChain([capturedTransport, 'optionalAccess', _1052 => _1052.sessionId]));
+        }, _optionalChain([capturedTransport, 'optionalAccess', _1062 => _1062.sessionId]));
       } else {
-        await _optionalChain([capturedTransport, 'optionalAccess', _1053 => _1053.send, 'call', _1054 => _1054(response)]);
+        await _optionalChain([capturedTransport, 'optionalAccess', _1063 => _1063.send, 'call', _1064 => _1064(response)]);
       }
     }, async (error49) => {
       if (abortController.signal.aborted) {
@@ -276110,9 +276323,9 @@ var Protocol = class {
           type: "error",
           message: errorResponse,
           timestamp: Date.now()
-        }, _optionalChain([capturedTransport, 'optionalAccess', _1055 => _1055.sessionId]));
+        }, _optionalChain([capturedTransport, 'optionalAccess', _1065 => _1065.sessionId]));
       } else {
-        await _optionalChain([capturedTransport, 'optionalAccess', _1056 => _1056.send, 'call', _1057 => _1057(errorResponse)]);
+        await _optionalChain([capturedTransport, 'optionalAccess', _1066 => _1066.send, 'call', _1067 => _1067(errorResponse)]);
       }
     }).catch((error49) => this._onerror(new Error(`Failed to send response: ${error49}`))).finally(() => {
       if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
@@ -276191,7 +276404,7 @@ var Protocol = class {
    * Closes the connection.
    */
   async close() {
-    await _optionalChain([this, 'access', _1058 => _1058._transport, 'optionalAccess', _1059 => _1059.close, 'call', _1060 => _1060()]);
+    await _optionalChain([this, 'access', _1068 => _1068._transport, 'optionalAccess', _1069 => _1069.close, 'call', _1070 => _1070()]);
   }
   /**
    * Sends a request and returns an AsyncGenerator that yields response messages.
@@ -276268,9 +276481,9 @@ var Protocol = class {
           yield { type: "result", result };
           return;
         }
-        const pollInterval = _nullishCoalesce(_nullishCoalesce(task6.pollInterval, () => ( _optionalChain([this, 'access', _1061 => _1061._options, 'optionalAccess', _1062 => _1062.defaultTaskPollInterval]))), () => ( 1e3));
+        const pollInterval = _nullishCoalesce(_nullishCoalesce(task6.pollInterval, () => ( _optionalChain([this, 'access', _1071 => _1071._options, 'optionalAccess', _1072 => _1072.defaultTaskPollInterval]))), () => ( 1e3));
         await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
-        _optionalChain([options, 'optionalAccess', _1063 => _1063.signal, 'optionalAccess', _1064 => _1064.throwIfAborted, 'call', _1065 => _1065()]);
+        _optionalChain([options, 'optionalAccess', _1073 => _1073.signal, 'optionalAccess', _1074 => _1074.throwIfAborted, 'call', _1075 => _1075()]);
       }
     } catch (error49) {
       yield {
@@ -276294,7 +276507,7 @@ var Protocol = class {
         earlyReject(new Error("Not connected"));
         return;
       }
-      if (_optionalChain([this, 'access', _1066 => _1066._options, 'optionalAccess', _1067 => _1067.enforceStrictCapabilities]) === true) {
+      if (_optionalChain([this, 'access', _1076 => _1076._options, 'optionalAccess', _1077 => _1077.enforceStrictCapabilities]) === true) {
         try {
           this.assertCapabilityForMethod(request.method);
           if (task5) {
@@ -276305,19 +276518,19 @@ var Protocol = class {
           return;
         }
       }
-      _optionalChain([options, 'optionalAccess', _1068 => _1068.signal, 'optionalAccess', _1069 => _1069.throwIfAborted, 'call', _1070 => _1070()]);
+      _optionalChain([options, 'optionalAccess', _1078 => _1078.signal, 'optionalAccess', _1079 => _1079.throwIfAborted, 'call', _1080 => _1080()]);
       const messageId = this._requestMessageId++;
       const jsonrpcRequest = {
         ...request,
         jsonrpc: "2.0",
         id: messageId
       };
-      if (_optionalChain([options, 'optionalAccess', _1071 => _1071.onprogress])) {
+      if (_optionalChain([options, 'optionalAccess', _1081 => _1081.onprogress])) {
         this._progressHandlers.set(messageId, options.onprogress);
         jsonrpcRequest.params = {
           ...request.params,
           _meta: {
-            ..._optionalChain([request, 'access', _1072 => _1072.params, 'optionalAccess', _1073 => _1073._meta]) || {},
+            ..._optionalChain([request, 'access', _1082 => _1082.params, 'optionalAccess', _1083 => _1083._meta]) || {},
             progressToken: messageId
           }
         };
@@ -276332,7 +276545,7 @@ var Protocol = class {
         jsonrpcRequest.params = {
           ...jsonrpcRequest.params,
           _meta: {
-            ..._optionalChain([jsonrpcRequest, 'access', _1074 => _1074.params, 'optionalAccess', _1075 => _1075._meta]) || {},
+            ..._optionalChain([jsonrpcRequest, 'access', _1084 => _1084.params, 'optionalAccess', _1085 => _1085._meta]) || {},
             [RELATED_TASK_META_KEY]: relatedTask
           }
         };
@@ -276341,19 +276554,19 @@ var Protocol = class {
         this._responseHandlers.delete(messageId);
         this._progressHandlers.delete(messageId);
         this._cleanupTimeout(messageId);
-        _optionalChain([this, 'access', _1076 => _1076._transport, 'optionalAccess', _1077 => _1077.send, 'call', _1078 => _1078({
+        _optionalChain([this, 'access', _1086 => _1086._transport, 'optionalAccess', _1087 => _1087.send, 'call', _1088 => _1088({
           jsonrpc: "2.0",
           method: "notifications/cancelled",
           params: {
             requestId: messageId,
             reason: String(reason)
           }
-        }, { relatedRequestId, resumptionToken, onresumptiontoken }), 'access', _1079 => _1079.catch, 'call', _1080 => _1080((error50) => this._onerror(new Error(`Failed to send cancellation: ${error50}`)))]);
+        }, { relatedRequestId, resumptionToken, onresumptiontoken }), 'access', _1089 => _1089.catch, 'call', _1090 => _1090((error50) => this._onerror(new Error(`Failed to send cancellation: ${error50}`)))]);
         const error49 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
         reject5(error49);
       };
       this._responseHandlers.set(messageId, (response) => {
-        if (_optionalChain([options, 'optionalAccess', _1081 => _1081.signal, 'optionalAccess', _1082 => _1082.aborted])) {
+        if (_optionalChain([options, 'optionalAccess', _1091 => _1091.signal, 'optionalAccess', _1092 => _1092.aborted])) {
           return;
         }
         if (response instanceof Error) {
@@ -276370,13 +276583,13 @@ var Protocol = class {
           reject5(error49);
         }
       });
-      _optionalChain([options, 'optionalAccess', _1083 => _1083.signal, 'optionalAccess', _1084 => _1084.addEventListener, 'call', _1085 => _1085("abort", () => {
-        cancel(_optionalChain([options, 'optionalAccess', _1086 => _1086.signal, 'optionalAccess', _1087 => _1087.reason]));
+      _optionalChain([options, 'optionalAccess', _1093 => _1093.signal, 'optionalAccess', _1094 => _1094.addEventListener, 'call', _1095 => _1095("abort", () => {
+        cancel(_optionalChain([options, 'optionalAccess', _1096 => _1096.signal, 'optionalAccess', _1097 => _1097.reason]));
       })]);
-      const timeout4 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1088 => _1088.timeout]), () => ( DEFAULT_REQUEST_TIMEOUT_MSEC));
+      const timeout4 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1098 => _1098.timeout]), () => ( DEFAULT_REQUEST_TIMEOUT_MSEC));
       const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout: timeout4 }));
-      this._setupTimeout(messageId, timeout4, _optionalChain([options, 'optionalAccess', _1089 => _1089.maxTotalTimeout]), timeoutHandler, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1090 => _1090.resetTimeoutOnProgress]), () => ( false)));
-      const relatedTaskId = _optionalChain([relatedTask, 'optionalAccess', _1091 => _1091.taskId]);
+      this._setupTimeout(messageId, timeout4, _optionalChain([options, 'optionalAccess', _1099 => _1099.maxTotalTimeout]), timeoutHandler, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1100 => _1100.resetTimeoutOnProgress]), () => ( false)));
+      const relatedTaskId = _optionalChain([relatedTask, 'optionalAccess', _1101 => _1101.taskId]);
       if (relatedTaskId) {
         const responseResolver = (response) => {
           const handler = this._responseHandlers.get(messageId);
@@ -276443,7 +276656,7 @@ var Protocol = class {
       throw new Error("Not connected");
     }
     this.assertNotificationCapability(notification.method);
-    const relatedTaskId = _optionalChain([options, 'optionalAccess', _1092 => _1092.relatedTask, 'optionalAccess', _1093 => _1093.taskId]);
+    const relatedTaskId = _optionalChain([options, 'optionalAccess', _1102 => _1102.relatedTask, 'optionalAccess', _1103 => _1103.taskId]);
     if (relatedTaskId) {
       const jsonrpcNotification2 = {
         ...notification,
@@ -276451,7 +276664,7 @@ var Protocol = class {
         params: {
           ...notification.params,
           _meta: {
-            ..._optionalChain([notification, 'access', _1094 => _1094.params, 'optionalAccess', _1095 => _1095._meta]) || {},
+            ..._optionalChain([notification, 'access', _1104 => _1104.params, 'optionalAccess', _1105 => _1105._meta]) || {},
             [RELATED_TASK_META_KEY]: options.relatedTask
           }
         }
@@ -276463,8 +276676,8 @@ var Protocol = class {
       });
       return;
     }
-    const debouncedMethods = _nullishCoalesce(_optionalChain([this, 'access', _1096 => _1096._options, 'optionalAccess', _1097 => _1097.debouncedNotificationMethods]), () => ( []));
-    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !_optionalChain([options, 'optionalAccess', _1098 => _1098.relatedRequestId]) && !_optionalChain([options, 'optionalAccess', _1099 => _1099.relatedTask]);
+    const debouncedMethods = _nullishCoalesce(_optionalChain([this, 'access', _1106 => _1106._options, 'optionalAccess', _1107 => _1107.debouncedNotificationMethods]), () => ( []));
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !_optionalChain([options, 'optionalAccess', _1108 => _1108.relatedRequestId]) && !_optionalChain([options, 'optionalAccess', _1109 => _1109.relatedTask]);
     if (canDebounce) {
       if (this._pendingDebouncedNotifications.has(notification.method)) {
         return;
@@ -276479,19 +276692,19 @@ var Protocol = class {
           ...notification,
           jsonrpc: "2.0"
         };
-        if (_optionalChain([options, 'optionalAccess', _1100 => _1100.relatedTask])) {
+        if (_optionalChain([options, 'optionalAccess', _1110 => _1110.relatedTask])) {
           jsonrpcNotification2 = {
             ...jsonrpcNotification2,
             params: {
               ...jsonrpcNotification2.params,
               _meta: {
-                ..._optionalChain([jsonrpcNotification2, 'access', _1101 => _1101.params, 'optionalAccess', _1102 => _1102._meta]) || {},
+                ..._optionalChain([jsonrpcNotification2, 'access', _1111 => _1111.params, 'optionalAccess', _1112 => _1112._meta]) || {},
                 [RELATED_TASK_META_KEY]: options.relatedTask
               }
             }
           };
         }
-        _optionalChain([this, 'access', _1103 => _1103._transport, 'optionalAccess', _1104 => _1104.send, 'call', _1105 => _1105(jsonrpcNotification2, options), 'access', _1106 => _1106.catch, 'call', _1107 => _1107((error49) => this._onerror(error49))]);
+        _optionalChain([this, 'access', _1113 => _1113._transport, 'optionalAccess', _1114 => _1114.send, 'call', _1115 => _1115(jsonrpcNotification2, options), 'access', _1116 => _1116.catch, 'call', _1117 => _1117((error49) => this._onerror(error49))]);
       });
       return;
     }
@@ -276499,13 +276712,13 @@ var Protocol = class {
       ...notification,
       jsonrpc: "2.0"
     };
-    if (_optionalChain([options, 'optionalAccess', _1108 => _1108.relatedTask])) {
+    if (_optionalChain([options, 'optionalAccess', _1118 => _1118.relatedTask])) {
       jsonrpcNotification = {
         ...jsonrpcNotification,
         params: {
           ...jsonrpcNotification.params,
           _meta: {
-            ..._optionalChain([jsonrpcNotification, 'access', _1109 => _1109.params, 'optionalAccess', _1110 => _1110._meta]) || {},
+            ..._optionalChain([jsonrpcNotification, 'access', _1119 => _1119.params, 'optionalAccess', _1120 => _1120._meta]) || {},
             [RELATED_TASK_META_KEY]: options.relatedTask
           }
         }
@@ -276584,7 +276797,7 @@ var Protocol = class {
     if (!this._taskStore || !this._taskMessageQueue) {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
-    const maxQueueSize = _optionalChain([this, 'access', _1111 => _1111._options, 'optionalAccess', _1112 => _1112.maxTaskQueueSize]);
+    const maxQueueSize = _optionalChain([this, 'access', _1121 => _1121._options, 'optionalAccess', _1122 => _1122.maxTaskQueueSize]);
     await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
   }
   /**
@@ -276617,10 +276830,10 @@ var Protocol = class {
    * @returns Promise that resolves when an update occurs or rejects if aborted
    */
   async _waitForTaskUpdate(taskId, signal) {
-    let interval = _nullishCoalesce(_optionalChain([this, 'access', _1113 => _1113._options, 'optionalAccess', _1114 => _1114.defaultTaskPollInterval]), () => ( 1e3));
+    let interval = _nullishCoalesce(_optionalChain([this, 'access', _1123 => _1123._options, 'optionalAccess', _1124 => _1124.defaultTaskPollInterval]), () => ( 1e3));
     try {
-      const task5 = await _optionalChain([this, 'access', _1115 => _1115._taskStore, 'optionalAccess', _1116 => _1116.getTask, 'call', _1117 => _1117(taskId)]);
-      if (_optionalChain([task5, 'optionalAccess', _1118 => _1118.pollInterval])) {
+      const task5 = await _optionalChain([this, 'access', _1125 => _1125._taskStore, 'optionalAccess', _1126 => _1126.getTask, 'call', _1127 => _1127(taskId)]);
+      if (_optionalChain([task5, 'optionalAccess', _1128 => _1128.pollInterval])) {
         interval = task5.pollInterval;
       }
     } catch (e48) {
@@ -276860,7 +277073,7 @@ var ExperimentalServerTasks = class {
    */
   createMessageStream(params, options) {
     const clientCapabilities = this._server.getClientCapabilities();
-    if ((params.tools || params.toolChoice) && !_optionalChain([clientCapabilities, 'optionalAccess', _1119 => _1119.sampling, 'optionalAccess', _1120 => _1120.tools])) {
+    if ((params.tools || params.toolChoice) && !_optionalChain([clientCapabilities, 'optionalAccess', _1129 => _1129.sampling, 'optionalAccess', _1130 => _1130.tools])) {
       throw new Error("Client does not support sampling tools capability.");
     }
     if (params.messages.length > 0) {
@@ -276938,13 +277151,13 @@ var ExperimentalServerTasks = class {
     const mode2 = _nullishCoalesce(params.mode, () => ( "form"));
     switch (mode2) {
       case "url": {
-        if (!_optionalChain([clientCapabilities, 'optionalAccess', _1121 => _1121.elicitation, 'optionalAccess', _1122 => _1122.url])) {
+        if (!_optionalChain([clientCapabilities, 'optionalAccess', _1131 => _1131.elicitation, 'optionalAccess', _1132 => _1132.url])) {
           throw new Error("Client does not support url elicitation.");
         }
         break;
       }
       case "form": {
-        if (!_optionalChain([clientCapabilities, 'optionalAccess', _1123 => _1123.elicitation, 'optionalAccess', _1124 => _1124.form])) {
+        if (!_optionalChain([clientCapabilities, 'optionalAccess', _1133 => _1133.elicitation, 'optionalAccess', _1134 => _1134.form])) {
           throw new Error("Client does not support form elicitation.");
         }
         break;
@@ -277014,7 +277227,7 @@ function assertToolsCallTaskCapability(requests, method2, entityName) {
   }
   switch (method2) {
     case "tools/call":
-      if (!_optionalChain([requests, 'access', _1125 => _1125.tools, 'optionalAccess', _1126 => _1126.call])) {
+      if (!_optionalChain([requests, 'access', _1135 => _1135.tools, 'optionalAccess', _1136 => _1136.call])) {
         throw new Error(`${entityName} does not support task creation for tools/call (required for ${method2})`);
       }
       break;
@@ -277028,12 +277241,12 @@ function assertClientRequestTaskCapability(requests, method2, entityName) {
   }
   switch (method2) {
     case "sampling/createMessage":
-      if (!_optionalChain([requests, 'access', _1127 => _1127.sampling, 'optionalAccess', _1128 => _1128.createMessage])) {
+      if (!_optionalChain([requests, 'access', _1137 => _1137.sampling, 'optionalAccess', _1138 => _1138.createMessage])) {
         throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method2})`);
       }
       break;
     case "elicitation/create":
-      if (!_optionalChain([requests, 'access', _1129 => _1129.elicitation, 'optionalAccess', _1130 => _1130.create])) {
+      if (!_optionalChain([requests, 'access', _1139 => _1139.elicitation, 'optionalAccess', _1140 => _1140.create])) {
         throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method2})`);
       }
       break;
@@ -277056,14 +277269,14 @@ var Server2 = class extends Protocol {
       const currentLevel = this._loggingLevels.get(sessionId);
       return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
     };
-    this._capabilities = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1131 => _1131.capabilities]), () => ( {}));
-    this._instructions = _optionalChain([options, 'optionalAccess', _1132 => _1132.instructions]);
-    this._jsonSchemaValidator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1133 => _1133.jsonSchemaValidator]), () => ( new AjvJsonSchemaValidator()));
+    this._capabilities = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1141 => _1141.capabilities]), () => ( {}));
+    this._instructions = _optionalChain([options, 'optionalAccess', _1142 => _1142.instructions]);
+    this._jsonSchemaValidator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _1143 => _1143.jsonSchemaValidator]), () => ( new AjvJsonSchemaValidator()));
     this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
-    this.setNotificationHandler(InitializedNotificationSchema, () => _optionalChain([this, 'access', _1134 => _1134.oninitialized, 'optionalCall', _1135 => _1135()]));
+    this.setNotificationHandler(InitializedNotificationSchema, () => _optionalChain([this, 'access', _1144 => _1144.oninitialized, 'optionalCall', _1145 => _1145()]));
     if (this._capabilities.logging) {
       this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-        const transportSessionId = extra.sessionId || _optionalChain([extra, 'access', _1136 => _1136.requestInfo, 'optionalAccess', _1137 => _1137.headers, 'access', _1138 => _1138["mcp-session-id"]]) || void 0;
+        const transportSessionId = extra.sessionId || _optionalChain([extra, 'access', _1146 => _1146.requestInfo, 'optionalAccess', _1147 => _1147.headers, 'access', _1148 => _1148["mcp-session-id"]]) || void 0;
         const { level } = request.params;
         const parseResult = LoggingLevelSchema.safeParse(level);
         if (parseResult.success) {
@@ -277104,19 +277317,19 @@ var Server2 = class extends Protocol {
    */
   setRequestHandler(requestSchema, handler) {
     const shape = getObjectShape(requestSchema);
-    const methodSchema = _optionalChain([shape, 'optionalAccess', _1139 => _1139.method]);
+    const methodSchema = _optionalChain([shape, 'optionalAccess', _1149 => _1149.method]);
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
     let methodValue;
     if (isZ4Schema(methodSchema)) {
       const v4Schema = methodSchema;
-      const v4Def = _optionalChain([v4Schema, 'access', _1140 => _1140._zod, 'optionalAccess', _1141 => _1141.def]);
-      methodValue = _nullishCoalesce(_optionalChain([v4Def, 'optionalAccess', _1142 => _1142.value]), () => ( v4Schema.value));
+      const v4Def = _optionalChain([v4Schema, 'access', _1150 => _1150._zod, 'optionalAccess', _1151 => _1151.def]);
+      methodValue = _nullishCoalesce(_optionalChain([v4Def, 'optionalAccess', _1152 => _1152.value]), () => ( v4Schema.value));
     } else {
       const v3Schema = methodSchema;
       const legacyDef = v3Schema._def;
-      methodValue = _nullishCoalesce(_optionalChain([legacyDef, 'optionalAccess', _1143 => _1143.value]), () => ( v3Schema.value));
+      methodValue = _nullishCoalesce(_optionalChain([legacyDef, 'optionalAccess', _1153 => _1153.value]), () => ( v3Schema.value));
     }
     if (typeof methodValue !== "string") {
       throw new Error("Schema method literal must be a string");
@@ -277153,17 +277366,17 @@ var Server2 = class extends Protocol {
   assertCapabilityForMethod(method2) {
     switch (method2) {
       case "sampling/createMessage":
-        if (!_optionalChain([this, 'access', _1144 => _1144._clientCapabilities, 'optionalAccess', _1145 => _1145.sampling])) {
+        if (!_optionalChain([this, 'access', _1154 => _1154._clientCapabilities, 'optionalAccess', _1155 => _1155.sampling])) {
           throw new Error(`Client does not support sampling (required for ${method2})`);
         }
         break;
       case "elicitation/create":
-        if (!_optionalChain([this, 'access', _1146 => _1146._clientCapabilities, 'optionalAccess', _1147 => _1147.elicitation])) {
+        if (!_optionalChain([this, 'access', _1156 => _1156._clientCapabilities, 'optionalAccess', _1157 => _1157.elicitation])) {
           throw new Error(`Client does not support elicitation (required for ${method2})`);
         }
         break;
       case "roots/list":
-        if (!_optionalChain([this, 'access', _1148 => _1148._clientCapabilities, 'optionalAccess', _1149 => _1149.roots])) {
+        if (!_optionalChain([this, 'access', _1158 => _1158._clientCapabilities, 'optionalAccess', _1159 => _1159.roots])) {
           throw new Error(`Client does not support listing roots (required for ${method2})`);
         }
         break;
@@ -277195,7 +277408,7 @@ var Server2 = class extends Protocol {
         }
         break;
       case "notifications/elicitation/complete":
-        if (!_optionalChain([this, 'access', _1150 => _1150._clientCapabilities, 'optionalAccess', _1151 => _1151.elicitation, 'optionalAccess', _1152 => _1152.url])) {
+        if (!_optionalChain([this, 'access', _1160 => _1160._clientCapabilities, 'optionalAccess', _1161 => _1161.elicitation, 'optionalAccess', _1162 => _1162.url])) {
           throw new Error(`Client does not support URL elicitation (required for ${method2})`);
         }
         break;
@@ -277253,13 +277466,13 @@ var Server2 = class extends Protocol {
     }
   }
   assertTaskCapability(method2) {
-    assertClientRequestTaskCapability(_optionalChain([this, 'access', _1153 => _1153._clientCapabilities, 'optionalAccess', _1154 => _1154.tasks, 'optionalAccess', _1155 => _1155.requests]), method2, "Client");
+    assertClientRequestTaskCapability(_optionalChain([this, 'access', _1163 => _1163._clientCapabilities, 'optionalAccess', _1164 => _1164.tasks, 'optionalAccess', _1165 => _1165.requests]), method2, "Client");
   }
   assertTaskHandlerCapability(method2) {
     if (!this._capabilities) {
       return;
     }
-    assertToolsCallTaskCapability(_optionalChain([this, 'access', _1156 => _1156._capabilities, 'access', _1157 => _1157.tasks, 'optionalAccess', _1158 => _1158.requests]), method2, "Server");
+    assertToolsCallTaskCapability(_optionalChain([this, 'access', _1166 => _1166._capabilities, 'access', _1167 => _1167.tasks, 'optionalAccess', _1168 => _1168.requests]), method2, "Server");
   }
   async _oninitialize(request) {
     const requestedVersion = request.params.protocolVersion;
@@ -277294,7 +277507,7 @@ var Server2 = class extends Protocol {
   // Implementation
   async createMessage(params, options) {
     if (params.tools || params.toolChoice) {
-      if (!_optionalChain([this, 'access', _1159 => _1159._clientCapabilities, 'optionalAccess', _1160 => _1160.sampling, 'optionalAccess', _1161 => _1161.tools])) {
+      if (!_optionalChain([this, 'access', _1169 => _1169._clientCapabilities, 'optionalAccess', _1170 => _1170.sampling, 'optionalAccess', _1171 => _1171.tools])) {
         throw new Error("Client does not support sampling tools capability.");
       }
     }
@@ -277337,14 +277550,14 @@ var Server2 = class extends Protocol {
     const mode2 = _nullishCoalesce(params.mode, () => ( "form"));
     switch (mode2) {
       case "url": {
-        if (!_optionalChain([this, 'access', _1162 => _1162._clientCapabilities, 'optionalAccess', _1163 => _1163.elicitation, 'optionalAccess', _1164 => _1164.url])) {
+        if (!_optionalChain([this, 'access', _1172 => _1172._clientCapabilities, 'optionalAccess', _1173 => _1173.elicitation, 'optionalAccess', _1174 => _1174.url])) {
           throw new Error("Client does not support url elicitation.");
         }
         const urlParams = params;
         return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
       }
       case "form": {
-        if (!_optionalChain([this, 'access', _1165 => _1165._clientCapabilities, 'optionalAccess', _1166 => _1166.elicitation, 'optionalAccess', _1167 => _1167.form])) {
+        if (!_optionalChain([this, 'access', _1175 => _1175._clientCapabilities, 'optionalAccess', _1176 => _1176.elicitation, 'optionalAccess', _1177 => _1177.form])) {
           throw new Error("Client does not support form elicitation.");
         }
         const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
@@ -277376,7 +277589,7 @@ var Server2 = class extends Protocol {
    * @returns A function that emits the completion notification when awaited.
    */
   createElicitationCompletionNotifier(elicitationId, options) {
-    if (!_optionalChain([this, 'access', _1168 => _1168._clientCapabilities, 'optionalAccess', _1169 => _1169.elicitation, 'optionalAccess', _1170 => _1170.url])) {
+    if (!_optionalChain([this, 'access', _1178 => _1178._clientCapabilities, 'optionalAccess', _1179 => _1179.elicitation, 'optionalAccess', _1180 => _1180.url])) {
       throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
     }
     return () => this.notification({
@@ -277430,7 +277643,7 @@ function isCompletable(schema) {
 }
 function getCompleter(schema) {
   const meta3 = schema[COMPLETABLE_SYMBOL];
-  return _optionalChain([meta3, 'optionalAccess', _1171 => _1171.complete]);
+  return _optionalChain([meta3, 'optionalAccess', _1181 => _1181.complete]);
 }
 var McpZodTypeKind;
 (function(McpZodTypeKind2) {
@@ -277610,7 +277823,7 @@ var McpServer = class {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
         }
         const isTaskRequest = !!request.params.task;
-        const taskSupport = _optionalChain([tool, 'access', _1172 => _1172.execution, 'optionalAccess', _1173 => _1173.taskSupport]);
+        const taskSupport = _optionalChain([tool, 'access', _1182 => _1182.execution, 'optionalAccess', _1183 => _1183.taskSupport]);
         const isTaskHandler = "createTask" in tool.handler;
         if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
           throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
@@ -277785,7 +277998,7 @@ var McpServer = class {
       return EMPTY_COMPLETION_RESULT;
     }
     const promptShape = getObjectShape(prompt.argsSchema);
-    const field = _optionalChain([promptShape, 'optionalAccess', _1174 => _1174[request.params.argument.name]]);
+    const field = _optionalChain([promptShape, 'optionalAccess', _1184 => _1184[request.params.argument.name]]);
     if (!isCompletable(field)) {
       return EMPTY_COMPLETION_RESULT;
     }
@@ -278063,7 +278276,7 @@ var McpServer = class {
     this._registeredPrompts[name] = registeredPrompt;
     if (argsSchema) {
       const hasCompletable = Object.values(argsSchema).some((field) => {
-        const inner = field instanceof ZodOptional2 ? _optionalChain([field, 'access', _1175 => _1175._def, 'optionalAccess', _1176 => _1176.innerType]) : field;
+        const inner = field instanceof ZodOptional2 ? _optionalChain([field, 'access', _1185 => _1185._def, 'optionalAccess', _1186 => _1186.innerType]) : field;
         return isCompletable(inner);
       });
       if (hasCompletable) {
@@ -278284,7 +278497,7 @@ function promptArgumentsFromSchema(schema) {
 }
 function getMethodValue(schema) {
   const shape = getObjectShape(schema);
-  const methodSchema = _optionalChain([shape, 'optionalAccess', _1177 => _1177.method]);
+  const methodSchema = _optionalChain([shape, 'optionalAccess', _1187 => _1187.method]);
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
   }
@@ -278355,7 +278568,7 @@ var StdioServerTransport = class {
       this.processReadBuffer();
     };
     this._onerror = (error49) => {
-      _optionalChain([this, 'access', _1178 => _1178.onerror, 'optionalCall', _1179 => _1179(error49)]);
+      _optionalChain([this, 'access', _1188 => _1188.onerror, 'optionalCall', _1189 => _1189(error49)]);
     };
   }
   /**
@@ -278376,9 +278589,9 @@ var StdioServerTransport = class {
         if (message === null) {
           break;
         }
-        _optionalChain([this, 'access', _1180 => _1180.onmessage, 'optionalCall', _1181 => _1181(message)]);
+        _optionalChain([this, 'access', _1190 => _1190.onmessage, 'optionalCall', _1191 => _1191(message)]);
       } catch (error49) {
-        _optionalChain([this, 'access', _1182 => _1182.onerror, 'optionalCall', _1183 => _1183(error49)]);
+        _optionalChain([this, 'access', _1192 => _1192.onerror, 'optionalCall', _1193 => _1193(error49)]);
       }
     }
   }
@@ -278390,7 +278603,7 @@ var StdioServerTransport = class {
       this._stdin.pause();
     }
     this._readBuffer.clear();
-    _optionalChain([this, 'access', _1184 => _1184.onclose, 'optionalCall', _1185 => _1185()]);
+    _optionalChain([this, 'access', _1194 => _1194.onclose, 'optionalCall', _1195 => _1195()]);
   }
   send(message) {
     return new Promise((resolve7) => {
@@ -278431,7 +278644,7 @@ var Request2 = class extends GlobalRequest {
     if (typeof input === "object" && getRequestCache in input) {
       input = input[getRequestCache]();
     }
-    if (typeof _optionalChain([options, 'optionalAccess', _1186 => _1186.body, 'optionalAccess', _1187 => _1187.getReader]) !== "undefined") {
+    if (typeof _optionalChain([options, 'optionalAccess', _1196 => _1196.body, 'optionalAccess', _1197 => _1197.getReader]) !== "undefined") {
       ;
       _nullishCoalesce(options.duplex, () => ( (options.duplex = "half")));
     }
@@ -278630,9 +278843,9 @@ var Response22 = (_a3 = class {
     } else {
       _chunkDLBJL7R2cjs.__privateSet.call(void 0, this, _init, init);
     }
-    if (typeof body2 === "string" || typeof _optionalChain([body2, 'optionalAccess', _1188 => _1188.getReader]) !== "undefined" || body2 instanceof Blob || body2 instanceof Uint8Array) {
+    if (typeof body2 === "string" || typeof _optionalChain([body2, 'optionalAccess', _1198 => _1198.getReader]) !== "undefined" || body2 instanceof Blob || body2 instanceof Uint8Array) {
       ;
-      this[cacheKey] = [_optionalChain([init, 'optionalAccess', _1189 => _1189.status]) || 200, body2, headers2 || _optionalChain([init, 'optionalAccess', _1190 => _1190.headers])];
+      this[cacheKey] = [_optionalChain([init, 'optionalAccess', _1199 => _1199.status]) || 200, body2, headers2 || _optionalChain([init, 'optionalAccess', _1200 => _1200.headers])];
     }
   }
   [getResponseCache]() {
@@ -278652,7 +278865,7 @@ var Response22 = (_a3 = class {
     return this[getResponseCache]().headers;
   }
   get status() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _1191 => _1191[cacheKey], 'optionalAccess', _1192 => _1192[0]]), () => ( this[getResponseCache]().status));
+    return _nullishCoalesce(_optionalChain([this, 'access', _1201 => _1201[cacheKey], 'optionalAccess', _1202 => _1202[0]]), () => ( this[getResponseCache]().status));
   }
   get ok() {
     const status = this.status;
@@ -278767,7 +278980,7 @@ var drainIncoming = (incoming) => {
   if (incoming instanceof _http22.Http2ServerRequest) {
     try {
       ;
-      _optionalChain([incoming, 'access', _1193 => _1193.stream, 'optionalAccess', _1194 => _1194.close, 'optionalCall', _1195 => _1195(_http22.constants.NGHTTP2_NO_ERROR)]);
+      _optionalChain([incoming, 'access', _1203 => _1203.stream, 'optionalAccess', _1204 => _1204.close, 'optionalCall', _1205 => _1205(_http22.constants.NGHTTP2_NO_ERROR)]);
     } catch (e49) {
     }
     return;
@@ -278787,7 +279000,7 @@ var drainIncoming = (incoming) => {
     }
   };
   const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
-  _optionalChain([timer, 'access', _1196 => _1196.unref, 'optionalCall', _1197 => _1197()]);
+  _optionalChain([timer, 'access', _1206 => _1206.unref, 'optionalCall', _1207 => _1207()]);
   const onData = (chunk) => {
     bytesRead += chunk.length;
     if (bytesRead > MAX_DRAIN_BYTES) {
@@ -278859,12 +279072,12 @@ var responseViaCache = async (res, outgoing) => {
     outgoing.end(new Uint8Array(await body2.arrayBuffer()));
   } else {
     flushHeaders(outgoing);
-    await _optionalChain([writeFromReadableStream, 'call', _1198 => _1198(body2, outgoing), 'optionalAccess', _1199 => _1199.catch, 'call', _1200 => _1200(
+    await _optionalChain([writeFromReadableStream, 'call', _1208 => _1208(body2, outgoing), 'optionalAccess', _1209 => _1209.catch, 'call', _1210 => _1210(
       (e) => handleResponseError(e, outgoing)
     )]);
   }
   ;
-  _optionalChain([outgoing, 'access', _1201 => _1201[outgoingEnded], 'optionalCall', _1202 => _1202()]);
+  _optionalChain([outgoing, 'access', _1211 => _1211[outgoingEnded], 'optionalCall', _1212 => _1212()]);
 };
 var isPromise = (res) => typeof res.then === "function";
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
@@ -278940,7 +279153,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     outgoing.end();
   }
   ;
-  _optionalChain([outgoing, 'access', _1203 => _1203[outgoingEnded], 'optionalCall', _1204 => _1204()]);
+  _optionalChain([outgoing, 'access', _1213 => _1213[outgoingEnded], 'optionalCall', _1214 => _1214()]);
 };
 var getRequestListener = (fetchCallback, options = {}) => {
   const autoCleanupIncoming = _nullishCoalesce(options.autoCleanupIncoming, () => ( true));
@@ -279067,7 +279280,7 @@ var WebStandardStreamableHTTPServerTransport = class {
    */
   createJsonErrorResponse(status, code, message, options) {
     const error49 = { code, message };
-    if (_optionalChain([options, 'optionalAccess', _1205 => _1205.data]) !== void 0) {
+    if (_optionalChain([options, 'optionalAccess', _1215 => _1215.data]) !== void 0) {
       error49.data = options.data;
     }
     return new Response(JSON.stringify({
@@ -279078,7 +279291,7 @@ var WebStandardStreamableHTTPServerTransport = class {
       status,
       headers: {
         "Content-Type": "application/json",
-        ..._optionalChain([options, 'optionalAccess', _1206 => _1206.headers])
+        ..._optionalChain([options, 'optionalAccess', _1216 => _1216.headers])
       }
     });
   }
@@ -279094,7 +279307,7 @@ var WebStandardStreamableHTTPServerTransport = class {
       const hostHeader = req.headers.get("host");
       if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
         const error49 = `Invalid Host header: ${hostHeader}`;
-        _optionalChain([this, 'access', _1207 => _1207.onerror, 'optionalCall', _1208 => _1208(new Error(error49))]);
+        _optionalChain([this, 'access', _1217 => _1217.onerror, 'optionalCall', _1218 => _1218(new Error(error49))]);
         return this.createJsonErrorResponse(403, -32e3, error49);
       }
     }
@@ -279102,7 +279315,7 @@ var WebStandardStreamableHTTPServerTransport = class {
       const originHeader = req.headers.get("origin");
       if (originHeader && !this._allowedOrigins.includes(originHeader)) {
         const error49 = `Invalid Origin header: ${originHeader}`;
-        _optionalChain([this, 'access', _1209 => _1209.onerror, 'optionalCall', _1210 => _1210(new Error(error49))]);
+        _optionalChain([this, 'access', _1219 => _1219.onerror, 'optionalCall', _1220 => _1220(new Error(error49))]);
         return this.createJsonErrorResponse(403, -32e3, error49);
       }
     }
@@ -279163,8 +279376,8 @@ data:
    */
   async handleGetRequest(req) {
     const acceptHeader = req.headers.get("accept");
-    if (!_optionalChain([acceptHeader, 'optionalAccess', _1211 => _1211.includes, 'call', _1212 => _1212("text/event-stream")])) {
-      _optionalChain([this, 'access', _1213 => _1213.onerror, 'optionalCall', _1214 => _1214(new Error("Not Acceptable: Client must accept text/event-stream"))]);
+    if (!_optionalChain([acceptHeader, 'optionalAccess', _1221 => _1221.includes, 'call', _1222 => _1222("text/event-stream")])) {
+      _optionalChain([this, 'access', _1223 => _1223.onerror, 'optionalCall', _1224 => _1224(new Error("Not Acceptable: Client must accept text/event-stream"))]);
       return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
     }
     const sessionError = this.validateSession(req);
@@ -279182,7 +279395,7 @@ data:
       }
     }
     if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
-      _optionalChain([this, 'access', _1215 => _1215.onerror, 'optionalCall', _1216 => _1216(new Error("Conflict: Only one SSE stream is allowed per session"))]);
+      _optionalChain([this, 'access', _1225 => _1225.onerror, 'optionalCall', _1226 => _1226(new Error("Conflict: Only one SSE stream is allowed per session"))]);
       return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
     }
     const encoder = new TextEncoder();
@@ -279222,7 +279435,7 @@ data:
    */
   async replayEvents(lastEventId) {
     if (!this._eventStore) {
-      _optionalChain([this, 'access', _1217 => _1217.onerror, 'optionalCall', _1218 => _1218(new Error("Event store not configured"))]);
+      _optionalChain([this, 'access', _1227 => _1227.onerror, 'optionalCall', _1228 => _1228(new Error("Event store not configured"))]);
       return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
     }
     try {
@@ -279230,11 +279443,11 @@ data:
       if (this._eventStore.getStreamIdForEventId) {
         streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
         if (!streamId) {
-          _optionalChain([this, 'access', _1219 => _1219.onerror, 'optionalCall', _1220 => _1220(new Error("Invalid event ID format"))]);
+          _optionalChain([this, 'access', _1229 => _1229.onerror, 'optionalCall', _1230 => _1230(new Error("Invalid event ID format"))]);
           return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
         }
         if (this._streamMapping.get(streamId) !== void 0) {
-          _optionalChain([this, 'access', _1221 => _1221.onerror, 'optionalCall', _1222 => _1222(new Error("Conflict: Stream already has an active connection"))]);
+          _optionalChain([this, 'access', _1231 => _1231.onerror, 'optionalCall', _1232 => _1232(new Error("Conflict: Stream already has an active connection"))]);
           return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
         }
       }
@@ -279259,7 +279472,7 @@ data:
         send: async (eventId, message) => {
           const success2 = this.writeSSEEvent(streamController, encoder, message, eventId);
           if (!success2) {
-            _optionalChain([this, 'access', _1223 => _1223.onerror, 'optionalCall', _1224 => _1224(new Error("Failed replay events"))]);
+            _optionalChain([this, 'access', _1233 => _1233.onerror, 'optionalCall', _1234 => _1234(new Error("Failed replay events"))]);
             try {
               streamController.close();
             } catch (e51) {
@@ -279280,7 +279493,7 @@ data:
       });
       return new Response(readable, { headers: headers2 });
     } catch (error49) {
-      _optionalChain([this, 'access', _1225 => _1225.onerror, 'optionalCall', _1226 => _1226(error49)]);
+      _optionalChain([this, 'access', _1235 => _1235.onerror, 'optionalCall', _1236 => _1236(error49)]);
       return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
     }
   }
@@ -279301,7 +279514,7 @@ data:
       controller.enqueue(encoder.encode(eventData));
       return true;
     } catch (error49) {
-      _optionalChain([this, 'access', _1227 => _1227.onerror, 'optionalCall', _1228 => _1228(error49)]);
+      _optionalChain([this, 'access', _1237 => _1237.onerror, 'optionalCall', _1238 => _1238(error49)]);
       return false;
     }
   }
@@ -279309,7 +279522,7 @@ data:
    * Handles unsupported requests (PUT, PATCH, etc.)
    */
   handleUnsupportedRequest() {
-    _optionalChain([this, 'access', _1229 => _1229.onerror, 'optionalCall', _1230 => _1230(new Error("Method not allowed."))]);
+    _optionalChain([this, 'access', _1239 => _1239.onerror, 'optionalCall', _1240 => _1240(new Error("Method not allowed."))]);
     return new Response(JSON.stringify({
       jsonrpc: "2.0",
       error: {
@@ -279331,13 +279544,13 @@ data:
   async handlePostRequest(req, options) {
     try {
       const acceptHeader = req.headers.get("accept");
-      if (!_optionalChain([acceptHeader, 'optionalAccess', _1231 => _1231.includes, 'call', _1232 => _1232("application/json")]) || !acceptHeader.includes("text/event-stream")) {
-        _optionalChain([this, 'access', _1233 => _1233.onerror, 'optionalCall', _1234 => _1234(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"))]);
+      if (!_optionalChain([acceptHeader, 'optionalAccess', _1241 => _1241.includes, 'call', _1242 => _1242("application/json")]) || !acceptHeader.includes("text/event-stream")) {
+        _optionalChain([this, 'access', _1243 => _1243.onerror, 'optionalCall', _1244 => _1244(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"))]);
         return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
       }
       const ct = req.headers.get("content-type");
       if (!ct || !ct.includes("application/json")) {
-        _optionalChain([this, 'access', _1235 => _1235.onerror, 'optionalCall', _1236 => _1236(new Error("Unsupported Media Type: Content-Type must be application/json"))]);
+        _optionalChain([this, 'access', _1245 => _1245.onerror, 'optionalCall', _1246 => _1246(new Error("Unsupported Media Type: Content-Type must be application/json"))]);
         return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
       }
       const requestInfo = {
@@ -279345,13 +279558,13 @@ data:
         url: new URL(req.url)
       };
       let rawMessage;
-      if (_optionalChain([options, 'optionalAccess', _1237 => _1237.parsedBody]) !== void 0) {
+      if (_optionalChain([options, 'optionalAccess', _1247 => _1247.parsedBody]) !== void 0) {
         rawMessage = options.parsedBody;
       } else {
         try {
           rawMessage = await req.json();
         } catch (e53) {
-          _optionalChain([this, 'access', _1238 => _1238.onerror, 'optionalCall', _1239 => _1239(new Error("Parse error: Invalid JSON"))]);
+          _optionalChain([this, 'access', _1248 => _1248.onerror, 'optionalCall', _1249 => _1249(new Error("Parse error: Invalid JSON"))]);
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
@@ -279363,20 +279576,20 @@ data:
           messages = [JSONRPCMessageSchema.parse(rawMessage)];
         }
       } catch (e54) {
-        _optionalChain([this, 'access', _1240 => _1240.onerror, 'optionalCall', _1241 => _1241(new Error("Parse error: Invalid JSON-RPC message"))]);
+        _optionalChain([this, 'access', _1250 => _1250.onerror, 'optionalCall', _1251 => _1251(new Error("Parse error: Invalid JSON-RPC message"))]);
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       const isInitializationRequest = messages.some(isInitializeRequest);
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== void 0) {
-          _optionalChain([this, 'access', _1242 => _1242.onerror, 'optionalCall', _1243 => _1243(new Error("Invalid Request: Server already initialized"))]);
+          _optionalChain([this, 'access', _1252 => _1252.onerror, 'optionalCall', _1253 => _1253(new Error("Invalid Request: Server already initialized"))]);
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
         if (messages.length > 1) {
-          _optionalChain([this, 'access', _1244 => _1244.onerror, 'optionalCall', _1245 => _1245(new Error("Invalid Request: Only one initialization request is allowed"))]);
+          _optionalChain([this, 'access', _1254 => _1254.onerror, 'optionalCall', _1255 => _1255(new Error("Invalid Request: Only one initialization request is allowed"))]);
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
-        this.sessionId = _optionalChain([this, 'access', _1246 => _1246.sessionIdGenerator, 'optionalCall', _1247 => _1247()]);
+        this.sessionId = _optionalChain([this, 'access', _1256 => _1256.sessionIdGenerator, 'optionalCall', _1257 => _1257()]);
         this._initialized = true;
         if (this.sessionId && this._onsessioninitialized) {
           await Promise.resolve(this._onsessioninitialized(this.sessionId));
@@ -279395,7 +279608,7 @@ data:
       const hasRequests = messages.some(isJSONRPCRequest);
       if (!hasRequests) {
         for (const message of messages) {
-          _optionalChain([this, 'access', _1248 => _1248.onmessage, 'optionalCall', _1249 => _1249(message, { authInfo: _optionalChain([options, 'optionalAccess', _1250 => _1250.authInfo]), requestInfo })]);
+          _optionalChain([this, 'access', _1258 => _1258.onmessage, 'optionalCall', _1259 => _1259(message, { authInfo: _optionalChain([options, 'optionalAccess', _1260 => _1260.authInfo]), requestInfo })]);
         }
         return new Response(null, { status: 202 });
       }
@@ -279416,7 +279629,7 @@ data:
             }
           }
           for (const message of messages) {
-            _optionalChain([this, 'access', _1251 => _1251.onmessage, 'optionalCall', _1252 => _1252(message, { authInfo: _optionalChain([options, 'optionalAccess', _1253 => _1253.authInfo]), requestInfo })]);
+            _optionalChain([this, 'access', _1261 => _1261.onmessage, 'optionalCall', _1262 => _1262(message, { authInfo: _optionalChain([options, 'optionalAccess', _1263 => _1263.authInfo]), requestInfo })]);
           }
         });
       }
@@ -279466,11 +279679,11 @@ data:
             this.closeStandaloneSSEStream();
           };
         }
-        _optionalChain([this, 'access', _1254 => _1254.onmessage, 'optionalCall', _1255 => _1255(message, { authInfo: _optionalChain([options, 'optionalAccess', _1256 => _1256.authInfo]), requestInfo, closeSSEStream, closeStandaloneSSEStream })]);
+        _optionalChain([this, 'access', _1264 => _1264.onmessage, 'optionalCall', _1265 => _1265(message, { authInfo: _optionalChain([options, 'optionalAccess', _1266 => _1266.authInfo]), requestInfo, closeSSEStream, closeStandaloneSSEStream })]);
       }
       return new Response(readable, { status: 200, headers: headers2 });
     } catch (error49) {
-      _optionalChain([this, 'access', _1257 => _1257.onerror, 'optionalCall', _1258 => _1258(error49)]);
+      _optionalChain([this, 'access', _1267 => _1267.onerror, 'optionalCall', _1268 => _1268(error49)]);
       return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error49) });
     }
   }
@@ -279486,7 +279699,7 @@ data:
     if (protocolError) {
       return protocolError;
     }
-    await Promise.resolve(_optionalChain([this, 'access', _1259 => _1259._onsessionclosed, 'optionalCall', _1260 => _1260(this.sessionId)]));
+    await Promise.resolve(_optionalChain([this, 'access', _1269 => _1269._onsessionclosed, 'optionalCall', _1270 => _1270(this.sessionId)]));
     await this.close();
     return new Response(null, { status: 200 });
   }
@@ -279499,16 +279712,16 @@ data:
       return void 0;
     }
     if (!this._initialized) {
-      _optionalChain([this, 'access', _1261 => _1261.onerror, 'optionalCall', _1262 => _1262(new Error("Bad Request: Server not initialized"))]);
+      _optionalChain([this, 'access', _1271 => _1271.onerror, 'optionalCall', _1272 => _1272(new Error("Bad Request: Server not initialized"))]);
       return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
     }
     const sessionId = req.headers.get("mcp-session-id");
     if (!sessionId) {
-      _optionalChain([this, 'access', _1263 => _1263.onerror, 'optionalCall', _1264 => _1264(new Error("Bad Request: Mcp-Session-Id header is required"))]);
+      _optionalChain([this, 'access', _1273 => _1273.onerror, 'optionalCall', _1274 => _1274(new Error("Bad Request: Mcp-Session-Id header is required"))]);
       return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
     }
     if (sessionId !== this.sessionId) {
-      _optionalChain([this, 'access', _1265 => _1265.onerror, 'optionalCall', _1266 => _1266(new Error("Session not found"))]);
+      _optionalChain([this, 'access', _1275 => _1275.onerror, 'optionalCall', _1276 => _1276(new Error("Session not found"))]);
       return this.createJsonErrorResponse(404, -32001, "Session not found");
     }
     return void 0;
@@ -279529,7 +279742,7 @@ data:
   validateProtocolVersion(req) {
     const protocolVersion = req.headers.get("mcp-protocol-version");
     if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
-      _optionalChain([this, 'access', _1267 => _1267.onerror, 'optionalCall', _1268 => _1268(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`))]);
+      _optionalChain([this, 'access', _1277 => _1277.onerror, 'optionalCall', _1278 => _1278(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`))]);
       return this.createJsonErrorResponse(400, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
     }
     return void 0;
@@ -279540,7 +279753,7 @@ data:
     });
     this._streamMapping.clear();
     this._requestResponseMap.clear();
-    _optionalChain([this, 'access', _1269 => _1269.onclose, 'optionalCall', _1270 => _1270()]);
+    _optionalChain([this, 'access', _1279 => _1279.onclose, 'optionalCall', _1280 => _1280()]);
   }
   /**
    * Close an SSE stream for a specific request, triggering client reconnection.
@@ -279567,7 +279780,7 @@ data:
     }
   }
   async send(message, options) {
-    let requestId = _optionalChain([options, 'optionalAccess', _1271 => _1271.relatedRequestId]);
+    let requestId = _optionalChain([options, 'optionalAccess', _1281 => _1281.relatedRequestId]);
     if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
       requestId = message.id;
     }
@@ -279593,7 +279806,7 @@ data:
       throw new Error(`No connection established for request ID: ${String(requestId)}`);
     }
     const stream4 = this._streamMapping.get(streamId);
-    if (!this._enableJsonResponse && _optionalChain([stream4, 'optionalAccess', _1272 => _1272.controller]) && _optionalChain([stream4, 'optionalAccess', _1273 => _1273.encoder])) {
+    if (!this._enableJsonResponse && _optionalChain([stream4, 'optionalAccess', _1282 => _1282.controller]) && _optionalChain([stream4, 'optionalAccess', _1283 => _1283.encoder])) {
       let eventId;
       if (this._eventStore) {
         eventId = await this._eventStore.storeEvent(streamId, message);
@@ -279641,8 +279854,8 @@ var StreamableHTTPServerTransport = class {
     this._requestListener = getRequestListener(async (webRequest) => {
       const context = this._requestContext.get(webRequest);
       return this._webStandardTransport.handleRequest(webRequest, {
-        authInfo: _optionalChain([context, 'optionalAccess', _1274 => _1274.authInfo]),
-        parsedBody: _optionalChain([context, 'optionalAccess', _1275 => _1275.parsedBody])
+        authInfo: _optionalChain([context, 'optionalAccess', _1284 => _1284.authInfo]),
+        parsedBody: _optionalChain([context, 'optionalAccess', _1285 => _1285.parsedBody])
       });
     }, { overrideGlobalObjects: false });
   }
@@ -281321,7 +281534,7 @@ async function importServiceFromFile(serviceId, file2, options = {
     );
     const data2 = fs52.default.readFileSync(filePath, "utf8");
     const importData = JSON.parse(data2);
-    if (_optionalChain([importData, 'optionalAccess', _1276 => _1276.service, 'access', _1277 => _1277[serviceId]])) {
+    if (_optionalChain([importData, 'optionalAccess', _1286 => _1286.service, 'access', _1287 => _1287[serviceId]])) {
       await importService2(serviceId, importData, options);
       stopProgressIndicator2(
         indicatorId,
@@ -282603,7 +282816,7 @@ async function listRealms(long = false) {
   } catch (error49) {
     printMessage2(error49, "error");
     printMessage2(`Error listing realms: ${error49.message}`, "error");
-    printMessage2(_optionalChain([error49, 'access', _1278 => _1278.response, 'optionalAccess', _1279 => _1279.data]), "error");
+    printMessage2(_optionalChain([error49, 'access', _1288 => _1288.response, 'optionalAccess', _1289 => _1289.data]), "error");
   }
 }
 async function exportRealmById(realmId, file2, includeMeta = true) {
@@ -286824,7 +287037,7 @@ function createFrodoCompleter(rootBindings, docsByMethod, onMethodHint) {
     const tokenMatch = line.match(
       /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\.?)$/
     );
-    const token2 = _nullishCoalesce(_optionalChain([tokenMatch, 'optionalAccess', _1280 => _1280[1]]), () => ( ""));
+    const token2 = _nullishCoalesce(_optionalChain([tokenMatch, 'optionalAccess', _1290 => _1290[1]]), () => ( ""));
     if (!token2) return [[], line];
     const rootCandidates = Object.keys(rootBindings).filter(
       (rootName2) => rootName2.startsWith(token2)
@@ -286880,7 +287093,7 @@ function buildDocsByMethod(frodoInstance) {
 function registerOpenParenHint(replServer, rootBindings, docsByMethod, onHint) {
   process.stdin.on("keypress", (_char, key) => {
     const char = typeof _char === "string" ? _char : "";
-    const sequence = _nullishCoalesce(_optionalChain([key, 'optionalAccess', _1281 => _1281.sequence]), () => ( ""));
+    const sequence = _nullishCoalesce(_optionalChain([key, 'optionalAccess', _1291 => _1291.sequence]), () => ( ""));
     if (sequence !== "(" && char !== "(") return;
     const currentLine = _nullishCoalesce(replServer["line"], () => ( ""));
     const match2 = currentLine.match(
@@ -287033,7 +287246,7 @@ function createHelpContext(frodoInstance) {
         console.log(`${BOLD}Factory helpers:${RESET2}`);
         for (const fn of sortedFns) {
           const docs = idx.get(fn);
-          const sigHint = _optionalChain([docs, 'optionalAccess', _1282 => _1282.length]) ? `  ${DIM2}${docs[0].signature}${RESET2}` : "";
+          const sigHint = _optionalChain([docs, 'optionalAccess', _1292 => _1292.length]) ? `  ${DIM2}${docs[0].signature}${RESET2}` : "";
           console.log(`  frodo.${GREEN}${fn}${RESET2}${sigHint}`);
         }
       }
@@ -287088,7 +287301,7 @@ function createHelpContext(frodoInstance) {
       const sortedSubMods = [...subMods].sort(alphaSort);
       const methodCount = sortedMethods.length;
       const subModuleCount = sortedSubMods.length;
-      const moduleType = _optionalChain([findModulePath, 'call', _1283 => _1283(frodoInstance, target), 'optionalAccess', _1284 => _1284.replace, 'call', _1285 => _1285(
+      const moduleType = _optionalChain([findModulePath, 'call', _1293 => _1293(frodoInstance, target), 'optionalAccess', _1294 => _1294.replace, 'call', _1295 => _1295(
         /^frodo\./,
         ""
       )]) || "Module";
@@ -287154,7 +287367,7 @@ function createHelpContext(frodoInstance) {
       console.log("");
       for (const methodName of sortedMethods) {
         const docs = idx.get(methodName);
-        const doc = _nullishCoalesce(_optionalChain([docs, 'optionalAccess', _1286 => _1286.find, 'call', _1287 => _1287((d4) => d4.typeName === bestType)]), () => ( _optionalChain([docs, 'optionalAccess', _1288 => _1288[0]])));
+        const doc = _nullishCoalesce(_optionalChain([docs, 'optionalAccess', _1296 => _1296.find, 'call', _1297 => _1297((d4) => d4.typeName === bestType)]), () => ( _optionalChain([docs, 'optionalAccess', _1298 => _1298[0]])));
         if (doc) {
           const sig = doc.signature.length > 100 ? doc.signature.slice(0, 97) + "..." : doc.signature;
           console.log(`  ${YELLOW}${sig}${RESET2}`);
@@ -287406,7 +287619,7 @@ async function startRepl(allowAwait = false, host) {
       console.log(`${BOLD2}Shell dot-commands:${RESET3}`);
       const commands = replServer.commands;
       for (const name of Object.keys(commands).sort()) {
-        const helpText = _nullishCoalesce(_optionalChain([commands, 'access', _1289 => _1289[name], 'optionalAccess', _1290 => _1290.help]), () => ( ""));
+        const helpText = _nullishCoalesce(_optionalChain([commands, 'access', _1299 => _1299[name], 'optionalAccess', _1300 => _1300.help]), () => ( ""));
         console.log(`  ${GREEN2}.${name}${RESET3}  ${DIM3}${helpText}${RESET3}`);
       }
       this.displayPrompt();
@@ -287416,7 +287629,7 @@ async function startRepl(allowAwait = false, host) {
   process.stdin.on("keypress", (_char, key) => {
     const rl = replServer;
     const currentHistIdx = _nullishCoalesce(rl["_historyIndex"], () => ( -1));
-    if (_optionalChain([key, 'optionalAccess', _1291 => _1291.name]) === "down" && !historyNavigationActive && currentHistIdx === -1) {
+    if (_optionalChain([key, 'optionalAccess', _1301 => _1301.name]) === "down" && !historyNavigationActive && currentHistIdx === -1) {
       const currentLine = _nullishCoalesce(replServer.line, () => ( ""));
       if (currentLine.trim().length > 0) {
         const replHistory = _nullishCoalesce(rl["history"], () => ( []));
@@ -287428,15 +287641,15 @@ async function startRepl(allowAwait = false, host) {
         replServer.write(null, { ctrl: true, name: "u" });
       }
     }
-    if (_optionalChain([key, 'optionalAccess', _1292 => _1292.name]) === "up" || _optionalChain([key, 'optionalAccess', _1293 => _1293.name]) === "down") {
+    if (_optionalChain([key, 'optionalAccess', _1302 => _1302.name]) === "up" || _optionalChain([key, 'optionalAccess', _1303 => _1303.name]) === "down") {
       historyNavigationActive = true;
       return;
     }
-    if (_optionalChain([key, 'optionalAccess', _1294 => _1294.name]) === "return" || _optionalChain([key, 'optionalAccess', _1295 => _1295.name]) === "enter") {
+    if (_optionalChain([key, 'optionalAccess', _1304 => _1304.name]) === "return" || _optionalChain([key, 'optionalAccess', _1305 => _1305.name]) === "enter") {
       historyNavigationActive = false;
       return;
     }
-    if (_optionalChain([key, 'optionalAccess', _1296 => _1296.ctrl]) || _optionalChain([key, 'optionalAccess', _1297 => _1297.meta]) || typeof _optionalChain([key, 'optionalAccess', _1298 => _1298.name]) === "string") {
+    if (_optionalChain([key, 'optionalAccess', _1306 => _1306.ctrl]) || _optionalChain([key, 'optionalAccess', _1307 => _1307.meta]) || typeof _optionalChain([key, 'optionalAccess', _1308 => _1308.name]) === "string") {
       historyNavigationActive = false;
     }
   });
@@ -287858,7 +288071,7 @@ var compareVersions = (v12, v2) => {
 // package.json
 var package_default2 = {
   name: "@rockcarver/frodo-cli",
-  version: "4.0.0",
+  version: "4.0.1-0",
   type: "module",
   description: "A command line interface to manage ForgeRock Identity Cloud tenants, ForgeOps deployments, and classic deployments.",
   keywords: [
@@ -287962,7 +288175,7 @@ var package_default2 = {
   },
   devDependencies: {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@rockcarver/frodo-lib": "4.0.0",
+    "@rockcarver/frodo-lib": "4.0.1-6",
     "@types/colors": "^1.2.1",
     "@types/fs-extra": "^11.0.1",
     "@types/jest": "^29.2.3",
@@ -288007,6 +288220,10 @@ var package_default2 = {
     uuid: "^11.1.0",
     yesno: "^0.4.0",
     zod: "^4.3.6"
+  },
+  allowScripts: {
+    "esbuild@0.27.2": true,
+    "fsevents@2.3.3": true
   }
 };