@dual-os/atlassian-api 0.0.0-stage → 6.0.3

package/plugin-ks550tmj.js.map

@@ -0,0 +1,18 @@
+{
+  "version": 3,
+  "sources": ["../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/random.js", "../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Random.js", "../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Boolean.js", "../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Ref.js", "../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/encoding/Sse.js", "../../../../node_modules/.bun/@dual-os+sdk@0.8.1+a827849ded09603e/node_modules/@dual-os/sdk/dist/AgentChannelConformance.js", "../../../../node_modules/.bun/@dual-os+sdk@0.8.1+a827849ded09603e/node_modules/@dual-os/sdk/dist/Mcp.js", "../../../../node_modules/.bun/@dual-os+sdk@0.8.1+a827849ded09603e/node_modules/@dual-os/sdk/dist/Http.js", "../bundle-input/dist/auth.js"],
+  "sourcesContent": [
+    "import * as Context from \"../Context.js\";\n/** @internal */\nexport const Random = /*#__PURE__*/Context.Reference(\"effect/Random\", {\n  defaultValue: () => ({\n    nextIntUnsafe() {\n      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;\n    },\n    nextDoubleUnsafe() {\n      return Math.random();\n    }\n  })\n});\n/** @internal */\nexport const nextBetween = (min, max, draw) => {\n  const value = draw * (max - min) + min;\n  if (value !== max || min >= max || !Number.isFinite(max)) {\n    return value;\n  }\n  // Rounding can reach the excluded endpoint even for a draw below 1.\n  // Return its immediate predecessor, which is at least min for finite min < max.\n  if (max === 0) {\n    return -Number.MIN_VALUE;\n  }\n  const view = new DataView(new ArrayBuffer(8));\n  view.setFloat64(0, max);\n  const bits = view.getBigUint64(0);\n  view.setBigUint64(0, max > 0 ? bits - BigInt(1) : bits + BigInt(1));\n  return view.getFloat64(0);\n};\n//# sourceMappingURL=random.js.map",
+    "import * as Cause from \"./Cause.js\";\nimport * as SecureRandom from \"./crypto/SecureRandom.js\";\nimport * as Effect from \"./Effect.js\";\nimport { dual } from \"./Function.js\";\nimport * as random from \"./internal/random.js\";\nimport * as Predicate from \"./Predicate.js\";\n/**\n * Represents a service for generating pseudo-random numbers.\n *\n * **When to use**\n *\n * Use to access or provide the random-number generator service used by Effect\n * programs.\n *\n * **Gotchas**\n *\n * The default implementation is based on `Math.random` and is not\n * cryptographically secure. Replace the service with a cryptographically secure\n * implementation before using these generators for security-sensitive values.\n *\n * **Example** (Accessing the random service)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const float = yield* Random.next\n *   const integer = yield* Random.nextInt\n *   const inRange = yield* Random.nextIntBetween(1, 100)\n *   return [float, integer, inRange] as const\n * })\n *\n * await Effect.runPromise(program.pipe(Random.withSeed(\"example\"))) // => [0.1633802591287037, 3434461687501127, 1]\n * ```\n *\n * @stability stable\n * @category services\n * @since 2.0.0\n */\nexport const Random = random.Random;\nconst randomWith = f => Effect.withFiber(fiber => Effect.succeed(f(fiber.getRef(Random))));\n/**\n * Generates a random number between 0 (inclusive) and 1 (exclusive).\n *\n * **When to use**\n *\n * Use to generate a pseudo-random floating-point number in the standard\n * `[0, 1)` range.\n *\n * **Example** (Generating a random number)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.next.pipe(Random.withSeed(\"example\"))) // => 0.1633802591287037\n * ```\n *\n * @stability stable\n * @category generators\n * @since 2.0.0\n */\nexport const next = /*#__PURE__*/randomWith(r => r.nextDoubleUnsafe());\n/**\n * Generates a random boolean value.\n *\n * **When to use**\n *\n * Use to make a pseudo-random true-or-false choice.\n *\n * **Example** (Generating a random boolean)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.nextBoolean.pipe(Random.withSeed(\"example\"))) // => false\n * ```\n *\n * @stability stable\n * @category generators\n * @since 2.0.0\n */\nexport const nextBoolean = /*#__PURE__*/randomWith(r => r.nextDoubleUnsafe() > 0.5);\n/**\n * Generates a random integer between `Number.MIN_SAFE_INTEGER` (inclusive)\n * and `Number.MAX_SAFE_INTEGER` (inclusive).\n *\n * **When to use**\n *\n * Use to generate a pseudo-random safe integer across the full safe-integer\n * range.\n *\n * **Example** (Generating a random integer)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.nextInt.pipe(Random.withSeed(\"example\"))) // => -6064002158214091\n * ```\n *\n * @stability stable\n * @category generators\n * @since 2.0.0\n */\nexport const nextInt = /*#__PURE__*/randomWith(r => r.nextIntUnsafe());\n/**\n * Generates a random number between `min` (inclusive) and `max` (exclusive).\n *\n * **When to use**\n *\n * Use to generate a pseudo-random floating-point number within a numeric range.\n *\n * **Example** (Generating a bounded random number)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.nextBetween(0, 1).pipe(Random.withSeed(\"example\"))) // => 0.1633802591287037\n * ```\n *\n * @stability stable\n * @category generators\n * @since 4.0.0\n */\nexport const nextBetween = (min, max) => randomWith(r => random.nextBetween(min, max, r.nextDoubleUnsafe()));\n/**\n * Generates a random integer between `min` and `max`.\n *\n * **When to use**\n *\n * Use to generate a pseudo-random integer within a rounded numeric range.\n *\n * **Details**\n *\n * The lower bound is rounded up with `Math.ceil` and the upper bound is\n * rounded down with `Math.floor`. By default the range is inclusive; set\n * `options.halfOpen: true` to exclude the upper bound.\n *\n * **Example** (Generating a bounded random integer)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const diceRoll1 = yield* Random.nextIntBetween(1, 6)\n *   const diceRoll2 = yield* Random.nextIntBetween(1, 6, {\n *     halfOpen: true\n *   })\n *   const diceRoll3 = yield* Random.nextIntBetween(0, 10)\n *   return [diceRoll1, diceRoll2, diceRoll3]\n * })\n *\n * await Effect.runPromise(program.pipe(Random.withSeed(\"example\"))) // => [1, 4, 0]\n * ```\n *\n * @stability stable\n * @category generators\n * @since 2.0.0\n */\nexport const nextIntBetween = (min, max, options) => {\n  const extra = options?.halfOpen === true ? 0 : 1;\n  return randomWith(r => {\n    const minInt = Math.ceil(min);\n    const maxInt = Math.floor(max);\n    return Math.floor(r.nextDoubleUnsafe() * (maxInt - minInt + extra)) + minInt;\n  });\n};\n/**\n * Uses the pseudo-random number generator to shuffle the specified iterable.\n *\n * **When to use**\n *\n * Use to randomly reorder an iterable using the active `Random` service.\n *\n * **Example** (Shuffling values)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.shuffle([1, 2, 3, 4, 5]).pipe(Random.withSeed(\"example\"))) // => [4, 2, 5, 3, 1]\n * ```\n *\n * @stability stable\n * @category generators\n * @since 2.0.0\n */\nexport const shuffle = elements => randomWith(r => {\n  const buffer = Array.from(elements);\n  for (let i = buffer.length - 1; i >= 1; i = i - 1) {\n    const index = Math.min(i, Math.floor(r.nextDoubleUnsafe() * (i + 1)));\n    const value = buffer[i];\n    buffer[i] = buffer[index];\n    buffer[index] = value;\n  }\n  return buffer;\n});\n/**\n * Gets a random element from an iterable.\n *\n * **When to use**\n *\n * Use to select one value uniformly from a collection using the active `Random`\n * service.\n *\n * **Details**\n *\n * If the input type is known to be non-empty, the returned effect cannot fail.\n * Otherwise, empty iterables fail with `Cause.NoSuchElementError`.\n *\n * **Example** (Choosing a random value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * await Effect.runPromise(Random.choice([\"red\", \"green\", \"blue\"] as const).pipe(Random.withSeed(\"example\"))) // => \"red\"\n * ```\n *\n * @stability stable\n * @category generators\n * @since 3.6.0\n */\nexport const choice = elements => {\n  const buffer = Array.from(elements);\n  return buffer.length === 0 ? Effect.fail(new Cause.NoSuchElementError(\"Cannot select a random element from an empty array\")) : randomWith(r => buffer[Math.min(buffer.length - 1, Math.floor(r.nextDoubleUnsafe() * buffer.length))]);\n};\n/**\n * Seeds the pseudo-random number generator with the specified value.\n *\n * **When to use**\n *\n * Use to run an effect with a deterministic pseudo-random sequence.\n *\n * **Details**\n *\n * Using the same seed produces the same random sequence, which is useful for\n * tests and reproducible simulations.\n *\n * **Gotchas**\n *\n * Use an unpredictable seed when uniqueness or unpredictability matters.\n *\n * **Example** (Seeding random generation)\n *\n * ```ts import.meta.vitest\n * import { Effect, Random } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const value1 = yield* Random.next\n *   const value2 = yield* Random.next\n *   return [value1, value2]\n * })\n *\n * await Effect.runPromise(Effect.all([\n *   program.pipe(Random.withSeed(\"my-seed\")),\n *   program.pipe(Random.withSeed(\"my-seed\"))\n * ])) // => [[0.018368576514773527, 0.4010840628128671], [0.018368576514773527, 0.4010840628128671]]\n * ```\n *\n * @stability stable\n * @category providing services\n * @since 4.0.0\n */\nexport const withSeed = /*#__PURE__*/dual(2, (self, seed) => Effect.suspend(() => Effect.provideService(self, Random, ISAAC_CSPRNG(seed))));\n/*///////////////////////////////////////////////////////////////////////////////////////////////////\nThis is a derivative work copyright (c) 2025 Effectful Technologies Inc, under MIT license.\nThis is a derivative work copyright (c) 2018, William P. \"Mac\" McMeans, under BSD license.\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n3. Neither the name of isaacCSPRNG nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\nOriginal work copyright (c) 2012 Yves-Marie K. Rinquin, under MIT license.\nhttps://github.com/rubycon/isaac.js\n///////////////////////////////////////////////////////////////////////////////////////////////////*/\nfunction ISAAC_CSPRNG(userSeed) {\n  // Internal State\n  const memory = new Array(256);\n  const result = new Array(256);\n  let accumulator = 0;\n  let lastResult = 0;\n  let generation = 0;\n  let counter = 0;\n  // Initial Seed\n  const internalSeed = Predicate.isUndefined(userSeed) ? getInitialSeed() : userSeed;\n  seed(internalSeed);\n  function getInitialSeed() {\n    const view = new DataView(SecureRandom.randomBytesUnsafe(8).buffer);\n    return view.getUint32(0) + view.getUint32(4);\n  }\n  function reset() {\n    accumulator = 0;\n    lastResult = 0;\n    counter = 0;\n    for (let i = 0; i < 256; ++i) {\n      memory[i] = 0;\n      result[i] = 0;\n    }\n    generation = 0;\n  }\n  function seed(userSeed) {\n    // The golden ratio ( 2654435769 )\n    // See https://stackoverflow.com/questions/4948780/magic-number-in-boosthash-combine\n    const magicNumber = 0x9e3779b9;\n    let a = magicNumber;\n    let b = magicNumber;\n    let c = magicNumber;\n    let d = magicNumber;\n    let e = magicNumber;\n    let f = magicNumber;\n    let g = magicNumber;\n    let h = magicNumber;\n    let i = 0;\n    let seed;\n    if (Predicate.isString(userSeed)) {\n      seed = toIntArray(userSeed);\n    } else {\n      seed = [userSeed];\n    }\n    reset();\n    for (i = 0; i < seed.length; i++) {\n      result[i & 0xff] += seed[i];\n    }\n    function mix() {\n      a ^= b << 11;\n      d = add32(d, a);\n      b = add32(b, c);\n      b ^= c >>> 2;\n      e = add32(e, b);\n      c = add32(c, d);\n      c ^= d << 8;\n      f = add32(f, c);\n      d = add32(d, e);\n      d ^= e >>> 16;\n      g = add32(g, d);\n      e = add32(e, f);\n      e ^= f << 10;\n      h = add32(h, e);\n      f = add32(f, g);\n      f ^= g >>> 4;\n      a = add32(a, f);\n      g = add32(g, h);\n      g ^= h << 8;\n      b = add32(b, g);\n      h = add32(h, a);\n      h ^= a >>> 9;\n      c = add32(c, h);\n      a = add32(a, b);\n    }\n    // Scramble the seed\n    for (i = 0; i < 4; i++) {\n      mix();\n    }\n    for (i = 0; i < 256; i += 8) {\n      // Use all the information in the seed\n      a = add32(a, result[i]);\n      b = add32(b, result[i + 1]);\n      c = add32(c, result[i + 2]);\n      d = add32(d, result[i + 3]);\n      e = add32(e, result[i + 4]);\n      f = add32(f, result[i + 5]);\n      g = add32(g, result[i + 6]);\n      h = add32(h, result[i + 7]);\n      mix();\n      // Fill in the memory with messy stuff\n      memory[i] = a;\n      memory[i + 1] = b;\n      memory[i + 2] = c;\n      memory[i + 3] = d;\n      memory[i + 4] = e;\n      memory[i + 5] = f;\n      memory[i + 6] = g;\n      memory[i + 7] = h;\n    }\n    // Second pass to make sure seed affects memory\n    for (i = 0; i < 256; i += 8) {\n      a = add32(a, memory[i]);\n      b = add32(b, memory[i + 1]);\n      c = add32(c, memory[i + 2]);\n      d = add32(d, memory[i + 3]);\n      e = add32(e, memory[i + 4]);\n      f = add32(f, memory[i + 5]);\n      g = add32(g, memory[i + 6]);\n      h = add32(h, memory[i + 7]);\n      mix();\n      // Fill in the memory with messy stuff (again)\n      memory[i] = a;\n      memory[i + 1] = b;\n      memory[i + 2] = c;\n      memory[i + 3] = d;\n      memory[i + 4] = e;\n      memory[i + 5] = f;\n      memory[i + 6] = g;\n      memory[i + 7] = h;\n    }\n    pnrg();\n    generation = 256;\n  }\n  function pnrg(n) {\n    let i = 0;\n    let x = 0;\n    let y = 0;\n    n = Predicate.isUndefined(n) ? 1 : Math.abs(Math.floor(n));\n    while (n--) {\n      counter = add32(counter, 1);\n      lastResult = add32(lastResult, counter);\n      for (i = 0; i < 256; i++) {\n        switch (i & 3) {\n          case 0:\n            {\n              accumulator ^= accumulator << 13;\n              break;\n            }\n          case 1:\n            {\n              accumulator ^= accumulator >>> 6;\n              break;\n            }\n          case 2:\n            {\n              accumulator ^= accumulator << 2;\n              break;\n            }\n          case 3:\n            {\n              accumulator ^= accumulator >>> 16;\n              break;\n            }\n        }\n        accumulator = add32(memory[i + 128 & 0xff], accumulator);\n        x = memory[i];\n        memory[i] = add32(memory[x >>> 2 & 0xff], add32(accumulator, lastResult));\n        y = memory[i];\n        result[i] = add32(memory[y >>> 10 & 0xff], x);\n        lastResult = result[i];\n      }\n    }\n  }\n  /**\n   * Returns a signed, random integer in the range [-2^31, 2^31).\n   */\n  function nextInt32() {\n    if (!generation--) {\n      pnrg();\n      generation = 255;\n    }\n    return result[generation];\n  }\n  function nextIntUnsafe() {\n    return Math.floor(nextDoubleUnsafe() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;\n  }\n  /**\n   * Returns a 53-bit fraction in the range [0, 1).\n   */\n  function nextDoubleUnsafe() {\n    const hi = nextInt32() >>> 0 & 0x1FFFFF; // take top 21 bits\n    const lo = nextInt32() >>> 0; // full 32 bits\n    // 53-bit integer\n    const combined = hi * 4294967296 + lo;\n    return combined / 0x20000000000000; // [0, 1)\n  }\n  return {\n    nextIntUnsafe,\n    nextDoubleUnsafe\n  };\n}\n/**\n * 32-bit addition with overflow handling (JavaScript numbers are 53-bit).\n *\n * Example: add32(0xFFFFFFFF, 0x00000001) = 0x00000000 (wraps around)\n */\nfunction add32(x, y) {\n  // Add lower 16 bits separately to handle carry\n  // Example: x=0x12345678, y=0xABCDEF01\n  // lsb = (0x5678 + 0xEF01) = 0x14579\n  const lsb = (x & 0xffff) + (y & 0xffff);\n  // Add upper 16 bits + carry from lower addition\n  // msb = (0x1234 + 0xABCD + (0x14579 >>> 16)) = (0x1234 + 0xABCD + 0x1) = 0xBE02\n  const msb = (x >>> 16) + (y >>> 16) + (lsb >>> 16);\n  // Combine: upper 16 bits | lower 16 bits (masked to prevent double carry)\n  // return (0xBE02 << 16) | (0x14579 & 0xffff) = 0xBE024579\n  return msb << 16 | lsb & 0xffff;\n}\nconst seedEncoder = /*#__PURE__*/new TextEncoder();\n/**\n * Convert a string to UTF-8 encoded 32-bit integers (little-endian).\n */\nfunction toIntArray(seed) {\n  const bytes = seedEncoder.encode(seed);\n  const result = [];\n  for (let index = 0; index < bytes.length; index += 4) {\n    result.push((bytes[index] ?? 0) << 0 | (bytes[index + 1] ?? 0) << 8 | (bytes[index + 2] ?? 0) << 16 | (bytes[index + 3] ?? 0) << 24);\n  }\n  return result;\n}\n//# sourceMappingURL=Random.js.map",
+    "/**\n * Works with TypeScript `boolean` values.\n *\n * This module exposes the native `Boolean` constructor together with helpers\n * for checking values, choosing between lazy branches, combining booleans with\n * logical operations, checking collections with `every` or `some`, ordering\n * booleans, and reducing boolean values.\n *\n * @stability stable\n * @since 2.0.0\n */\nimport * as Equ from \"./Equivalence.js\";\nimport { dual } from \"./Function.js\";\nimport * as order from \"./Order.js\";\nimport * as predicate from \"./Predicate.js\";\nimport * as Reducer from \"./Reducer.js\";\n/**\n * Exposes the global boolean constructor for JavaScript truthiness\n * coercion.\n *\n * **When to use**\n *\n * Use to access native JavaScript truthiness coercion from the Effect module\n * namespace.\n *\n * **Gotchas**\n *\n * This follows native truthiness rules. For example, non-empty strings such as\n * `\"false\"` coerce to `true`.\n *\n * **Example** (Coercing values to booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.Boolean(1) // => true\n * Boolean.Boolean(\"false\") // => true\n * Boolean.Boolean(0) // => false\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 4.0.0\n */\nexport const Boolean = globalThis.Boolean;\n/**\n * Checks whether a value is a `boolean`.\n *\n * **When to use**\n *\n * Use to validate unknown input and narrow it to `boolean`.\n *\n * **Example** (Checking for booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.isBoolean(true) // => true\n * Boolean.isBoolean(\"true\") // => false\n * ```\n *\n * @stability stable\n * @category guards\n * @since 2.0.0\n */\nexport const isBoolean = predicate.isBoolean;\n/**\n * Chooses between two lazy branches based on a boolean value.\n *\n * **When to use**\n *\n * Use to choose between two lazy branches based on a boolean value.\n *\n * **Example** (Pattern matching on booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.match(true, {\n *   onFalse: () => \"It's false!\",\n *   onTrue: () => \"It's true!\"\n * }) // => \"It's true!\"\n * ```\n *\n * @stability stable\n * @category pattern matching\n * @since 2.0.0\n */\nexport const match = /*#__PURE__*/dual(2, (value, options) => value ? options.onTrue() : options.onFalse());\n/**\n * Provides an `Order` instance for `boolean` that allows comparing and sorting boolean values.\n * In this ordering, `false` is considered less than `true`.\n *\n * **When to use**\n *\n * Use when you need to sort or compare boolean values through APIs that accept\n * an ordering instance where `false` comes before `true`.\n *\n * **Example** (Comparing booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.Order(false, true) // => -1\n * Boolean.Order(true, false) // => 1\n * Boolean.Order(true, true) // => 0\n * ```\n *\n * @stability stable\n * @category instances\n * @since 2.0.0\n */\nexport const Order = order.Boolean;\n/**\n * Equivalence instance for booleans using strict equality (`===`).\n *\n * **When to use**\n *\n * Use when checking boolean equality through APIs that accept an equivalence\n * relation.\n *\n * **Example** (Comparing booleans for equivalence)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.Equivalence(true, true) // => true\n * Boolean.Equivalence(true, false) // => false\n * ```\n *\n * @stability stable\n * @category instances\n * @since 2.0.0\n */\nexport const Equivalence = Equ.Boolean;\n/**\n * Negates the given boolean: `!self`\n *\n * **When to use**\n *\n * Use to invert a boolean value.\n *\n * **Example** (Negating booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.not(true) // => false\n * Boolean.not(false) // => true\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const not = self => !self;\n/**\n * Combines two booleans using logical AND: `self && that`.\n *\n * **When to use**\n *\n * Use to require both boolean operands to be `true`.\n *\n * **Details**\n *\n * Supports both data-first and data-last forms.\n *\n * **Example** (Combining booleans with AND)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.and(true, true) // => true\n * Boolean.and(true, false) // => false\n * Boolean.and(false, true) // => false\n * Boolean.and(false, false) // => false\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const and = /*#__PURE__*/dual(2, (self, that) => self && that);\n/**\n * Combines two booleans using NAND: `!(self && that)`.\n *\n * **When to use**\n *\n * Use to negate a logical AND result.\n *\n * **Example** (Combining booleans with NAND)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.nand(true, true) // => false\n * Boolean.nand(true, false) // => true\n * Boolean.nand(false, true) // => true\n * Boolean.nand(false, false) // => true\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const nand = /*#__PURE__*/dual(2, (self, that) => !(self && that));\n/**\n * Combines two booleans using OR: `self || that`.\n *\n * **When to use**\n *\n * Use to accept when either boolean operand is `true`.\n *\n * **Example** (Combining booleans with OR)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.or(true, true) // => true\n * Boolean.or(true, false) // => true\n * Boolean.or(false, true) // => true\n * Boolean.or(false, false) // => false\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const or = /*#__PURE__*/dual(2, (self, that) => self || that);\n/**\n * Combines two booleans using NOR: `!(self || that)`.\n *\n * **When to use**\n *\n * Use to accept only when both boolean operands are `false`.\n *\n * **Example** (Combining booleans with NOR)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.nor(true, true) // => false\n * Boolean.nor(true, false) // => false\n * Boolean.nor(false, true) // => false\n * Boolean.nor(false, false) // => true\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const nor = /*#__PURE__*/dual(2, (self, that) => !(self || that));\n/**\n * Combines two booleans using XOR: `(!self && that) || (self && !that)`.\n *\n * **When to use**\n *\n * Use to accept when exactly one boolean operand is `true`.\n *\n * **Example** (Combining booleans with XOR)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.xor(true, true) // => false\n * Boolean.xor(true, false) // => true\n * Boolean.xor(false, true) // => true\n * Boolean.xor(false, false) // => false\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const xor = /*#__PURE__*/dual(2, (self, that) => !self && that || self && !that);\n/**\n * Combines two booleans using EQV (aka XNOR): `!xor(self, that)`.\n *\n * **When to use**\n *\n * Use to accept when both boolean operands have the same truth value.\n *\n * **Example** (Checking boolean equivalence)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.eqv(true, true) // => true\n * Boolean.eqv(true, false) // => false\n * Boolean.eqv(false, true) // => false\n * Boolean.eqv(false, false) // => true\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const eqv = /*#__PURE__*/dual(2, (self, that) => !xor(self, that));\n/**\n * Combines two booleans using an implication: `(!self || that)`.\n *\n * **When to use**\n *\n * Use to model logical implication between a condition and a consequence.\n *\n * **Example** (Checking boolean implication)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.implies(true, true) // => true\n * Boolean.implies(true, false) // => false\n * Boolean.implies(false, true) // => true\n * Boolean.implies(false, false) // => true\n * ```\n *\n * @stability stable\n * @category combinators\n * @since 2.0.0\n */\nexport const implies = /*#__PURE__*/dual(2, (self, that) => self ? that : true);\n/**\n * Checks whether every boolean in a collection is `true`.\n *\n * **When to use**\n *\n * Use to check that every boolean in an iterable is `true`.\n *\n * **Example** (Checking every boolean)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.every([true, true, true]) // => true\n * Boolean.every([true, false, true]) // => false\n * ```\n *\n * @see {@link some} for checking whether at least one value is `true`\n * @see {@link ReducerAnd} for reducing booleans with AND through a `Reducer`\n *\n * @stability stable\n * @category predicates\n * @since 2.0.0\n */\nexport const every = collection => {\n  for (const b of collection) {\n    if (!b) {\n      return false;\n    }\n  }\n  return true;\n};\n/**\n * Checks whether at least one boolean in a collection is `true`.\n *\n * **When to use**\n *\n * Use to check that at least one boolean in an iterable is `true`.\n *\n * **Example** (Checking some booleans)\n *\n * ```ts import.meta.vitest\n * import { Boolean } from \"effect\"\n *\n * Boolean.some([true, false, true]) // => true\n * Boolean.some([false, false, false]) // => false\n * ```\n *\n * @see {@link every} for checking whether all values are `true`\n * @see {@link ReducerOr} for reducing booleans with OR through a `Reducer`\n *\n * @stability stable\n * @category predicates\n * @since 2.0.0\n */\nexport const some = collection => {\n  for (const b of collection) {\n    if (b) {\n      return true;\n    }\n  }\n  return false;\n};\n/**\n * Reducer for combining `boolean`s using AND.\n *\n * **When to use**\n *\n * Use to require every accumulated boolean to be `true` through APIs that\n * consume a `Reducer`.\n *\n * **Details**\n *\n * The `initialValue` is `true`, so `combineAll([])` returns `true`.\n *\n * **Gotchas**\n *\n * `combineAll` uses the default left-to-right `Reducer.make` fold and does not\n * short-circuit on `false`.\n *\n * @see {@link ReducerOr} for reducing with OR semantics\n * @see {@link every} for checking an iterable directly\n *\n * @stability stable\n * @category math\n * @since 4.0.0\n */\nexport const ReducerAnd = /*#__PURE__*/Reducer.make((a, b) => a && b, true);\n/**\n * Reducer for combining `boolean`s using OR.\n *\n * **When to use**\n *\n * Use to reduce boolean values where the result should be `true` if any\n * combined value is `true`.\n *\n * **Details**\n *\n * The `initialValue` is `false`.\n *\n * @see {@link ReducerAnd} for reducing with AND semantics\n * @see {@link some} for checking an iterable directly\n *\n * @stability stable\n * @category math\n * @since 4.0.0\n */\nexport const ReducerOr = /*#__PURE__*/Reducer.make((a, b) => a || b, false);\n//# sourceMappingURL=Boolean.js.map",
+    "/**\n * Stores fiber-safe mutable state inside Effect programs.\n *\n * A `Ref<A>` holds one value and exposes reads, writes, and atomic\n * transformations as effects, so state changes compose with Effect's\n * concurrency model. This module includes constructors, safe and unsafe reads,\n * set and get-and-set helpers, update and modify helpers, and conditional\n * update variants that leave the value unchanged when an `Option.none` result\n * is returned.\n *\n * @stability stable\n * @since 2.0.0\n */\nimport * as Effect from \"./Effect.js\";\nimport { dual, identity } from \"./Function.js\";\nimport { PipeInspectableProto } from \"./internal/core.js\";\nimport * as MutableRef from \"./MutableRef.js\";\nconst TypeId = \"~effect/Ref\";\nconst RefProto = {\n  [TypeId]: {\n    _A: identity\n  },\n  ...PipeInspectableProto,\n  toJSON() {\n    return {\n      _id: \"Ref\",\n      ref: this.ref\n    };\n  }\n};\n/**\n * Creates a new Ref with the specified initial value (unsafe version).\n *\n * **When to use**\n *\n * Use when you need immediate synchronous construction and can guarantee\n * that creating the `Ref` outside of `Effect` is safe.\n *\n * **Gotchas**\n *\n * Prefer `Ref.make` for Effect-wrapped creation in Effect programs.\n *\n * **Example** (Creating a ref unsafely)\n *\n * ```ts import.meta.vitest\n * import { Ref } from \"effect\"\n *\n * const counter = Ref.makeUnsafe(0)\n * Ref.getUnsafe(counter) // => 0\n * ```\n *\n * @stability stable\n * @category constructors\n * @since 4.0.0\n */\nexport const makeUnsafe = value => {\n  const self = Object.create(RefProto);\n  self.ref = MutableRef.make(value);\n  return self;\n};\n/**\n * Creates a new Ref with the specified initial value.\n *\n * **When to use**\n *\n * Use to create a `Ref` for shared mutable state inside an Effect program.\n *\n * **Example** (Creating a ref)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const ref = yield* Ref.make(42)\n *   return yield* Ref.get(ref)\n * })\n *\n * await Effect.runPromise(program) // => 42\n * ```\n *\n * @see {@link makeUnsafe} for synchronous construction outside Effect code\n *\n * @stability stable\n * @category constructors\n * @since 2.0.0\n */\nexport const make = value => Effect.sync(() => makeUnsafe(value));\n/**\n * Gets the current value of the Ref.\n *\n * **When to use**\n *\n * Use to read the current `Ref` value without changing it.\n *\n * **Example** (Getting the current value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const ref = yield* Ref.make(42)\n *   return yield* Ref.get(ref)\n * })\n *\n * await Effect.runPromise(program) // => 42\n * ```\n *\n * @see {@link set} for replacing the current value\n *\n * @stability stable\n * @category getters\n * @since 2.0.0\n */\nexport const get = self => Effect.sync(() => self.ref.current);\n/**\n * Sets the value of the Ref to the specified value.\n *\n * **When to use**\n *\n * Use to replace the current `Ref` value with a known value.\n *\n * **Example** (Setting a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const ref = yield* Ref.make(0)\n *   yield* Ref.set(ref, 42)\n *   return yield* Ref.get(ref)\n * })\n *\n * const program2 = Effect.gen(function*() {\n *   const ref = yield* Ref.make(0)\n *   yield* Ref.set(ref, 100)\n *   return yield* Ref.get(ref)\n * })\n *\n * await Effect.runPromise(program) // => 42\n * await Effect.runPromise(program2) // => 100\n * ```\n *\n * @see {@link getAndSet} for setting while returning the previous value\n * @see {@link setAndGet} for setting while returning the new value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const set = /*#__PURE__*/dual(2, (self, value) => Effect.sync(() => MutableRef.set(self.ref, value)));\n/**\n * Gets the current value of the Ref, sets it to the specified value, and returns the previous value atomically.\n *\n * **When to use**\n *\n * Use to replace a plain `Ref` value while returning the previous value.\n *\n * **Example** (Replacing a value atomically)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const ref = yield* Ref.make(\"initial\")\n *\n *   const previous = yield* Ref.getAndSet(ref, \"updated\")\n *   const current = yield* Ref.get(ref)\n *   return [previous, current]\n * })\n *\n * await Effect.runPromise(program) // => [\"initial\", \"updated\"]\n * ```\n *\n * @see {@link set} for setting without returning the previous value\n * @see {@link getAndUpdate} for deriving the new value from the previous value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndSet = /*#__PURE__*/dual(2, (self, value) => Effect.sync(() => {\n  const current = self.ref.current;\n  self.ref.current = value;\n  return current;\n}));\n/**\n * Gets the current value of the Ref, updates it with the given function, and returns the previous value atomically.\n *\n * **When to use**\n *\n * Use to derive a new `Ref` value while returning the previous value.\n *\n * **Example** (Updating and returning the previous value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(10)\n *\n *   const previous = yield* Ref.getAndUpdate(counter, (n) => n * 2)\n *   const current = yield* Ref.get(counter)\n *   return [previous, current]\n * })\n *\n * await Effect.runPromise(program) // => [10, 20]\n * ```\n *\n * @see {@link update} for updating without returning the previous value\n * @see {@link updateAndGet} for returning the new value instead\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndUpdate = /*#__PURE__*/dual(2, (self, f) => Effect.sync(() => {\n  const current = self.ref.current;\n  self.ref.current = f(current);\n  return current;\n}));\n/**\n * Gets the current value of the Ref and updates it atomically with the given partial function.\n *\n * **When to use**\n *\n * Use to return the previous `Ref` value while applying a conditional update.\n *\n * **Details**\n *\n * If the partial function returns `Option.some`, the Ref is updated with the\n * new value. If it returns `Option.none`, the Ref is left unchanged. The effect\n * always returns the value that was in the Ref before the attempted update.\n *\n * **Example** (Conditionally updating and returning the previous value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *\n *   const previous1 = yield* Ref.getAndUpdateSome(\n *     counter,\n *     (n) => n > 3 ? Option.some(n * 2) : Option.none()\n *   )\n *   const current1 = yield* Ref.get(counter)\n *   const previous2 = yield* Ref.getAndUpdateSome(\n *     counter,\n *     (n) => n < 3 ? Option.some(n * 2) : Option.none()\n *   )\n *   const current2 = yield* Ref.get(counter)\n *   return [previous1, current1, previous2, current2]\n * })\n *\n * await Effect.runPromise(program) // => [5, 10, 10, 10]\n * ```\n *\n * @see {@link getAndUpdate} for always applying an update\n * @see {@link updateSome} for conditional updates without returning the previous value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const getAndUpdateSome = /*#__PURE__*/dual(2, (self, pf) => Effect.sync(() => {\n  const current = self.ref.current;\n  const option = pf(current);\n  if (option._tag === \"Some\") {\n    self.ref.current = option.value;\n  }\n  return current;\n}));\n/**\n * Sets the value of the Ref atomically to the specified value and returns the new value.\n *\n * **When to use**\n *\n * Use when you want to set a `Ref` value and immediately get it back in one\n * atomic operation.\n *\n * **Example** (Setting and returning the new value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const ref = yield* Ref.make(10)\n *\n *   const newValue = yield* Ref.setAndGet(ref, 42)\n *   const current = yield* Ref.get(ref)\n *   return [newValue, current]\n * })\n *\n * const program2 = Effect.gen(function*() {\n *   const counter = yield* Ref.make(0)\n *   return yield* Ref.setAndGet(counter, 20)\n * })\n *\n * await Effect.runPromise(program) // => [42, 42]\n * await Effect.runPromise(program2) // => 20\n * ```\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const setAndGet = /*#__PURE__*/dual(2, (self, value) => Effect.sync(() => self.ref.current = value));\n/**\n * Modifies the value of the Ref atomically using the given function.\n *\n * **When to use**\n *\n * Use to compute both a separate return value and the next stored `Ref` value\n * in one atomic update.\n *\n * **Details**\n *\n * The function receives the current value and returns a tuple of\n * `[result, newValue]`. The Ref is updated with `newValue`, and `result` is\n * returned by the effect.\n *\n * **Example** (Modifying a value atomically)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(10)\n *\n *   const result = yield* Ref.modify(counter, (n) => [\n *     `Previous value was ${n}`,\n *     n * 2\n *   ])\n *   const current = yield* Ref.get(counter)\n *   return [result, current]\n * })\n *\n * const program2 = Effect.gen(function*() {\n *   const state = yield* Ref.make({ count: 0, total: 0 })\n *   return yield* Ref.modify(state, (s) => [\n *     s.count,\n *     { count: s.count + 1, total: s.total + s.count + 1 }\n *   ])\n * })\n *\n * await Effect.runPromise(program) // => [\"Previous value was 10\", 20]\n * await Effect.runPromise(program2) // => 0\n * ```\n *\n * @see {@link updateAndGet} for returning the new stored value\n * @see {@link modifySome} for optionally updating while returning a separate result\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const modify = /*#__PURE__*/dual(2, (self, f) => Effect.sync(() => {\n  const [b, a] = f(self.ref.current);\n  self.ref.current = a;\n  return b;\n}));\n/**\n * Computes a result atomically and optionally updates the value of the `Ref`.\n *\n * **When to use**\n *\n * Use to compute a return value while optionally updating a plain `Ref`.\n *\n * **Details**\n *\n * The callback receives the current value and returns `[result, nextValue]`,\n * where `nextValue` is an `Option`. If `nextValue` is `Option.some(value)`,\n * the `Ref` is updated to `value`; if it is `Option.none()`, the `Ref` is left\n * unchanged. The returned effect always succeeds with `result`.\n *\n * **Example** (Conditionally modifying a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *\n *   const result1 = yield* Ref.modifySome(\n *     counter,\n *     (n) =>\n *       n > 3\n *         ? [`incremented ${n}`, Option.some(n + 10)]\n *         : [\"no change\", Option.none()]\n *   )\n *   const current1 = yield* Ref.get(counter)\n *   const result2 = yield* Ref.modifySome(\n *     counter,\n *     (n) =>\n *       n < 10\n *         ? [`decremented ${n}`, Option.some(n - 5)]\n *         : [\"no change\", Option.none()]\n *   )\n *   const current2 = yield* Ref.get(counter)\n *   return [result1, current1, result2, current2]\n * })\n *\n * await Effect.runPromise(program) // => [\"incremented 5\", 15, \"no change\", 15]\n * ```\n *\n * @see {@link modify} for always storing a new value\n * @see {@link updateSome} for optional updates without a separate return value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const modifySome = /*#__PURE__*/dual(2, (self, pf) => modify(self, value => {\n  const [b, option] = pf(value);\n  return [b, option._tag === \"None\" ? value : option.value];\n}));\n/**\n * Updates the value of the Ref atomically using the given function.\n *\n * **When to use**\n *\n * Use to apply a `Ref` state transition without returning a value.\n *\n * **Example** (Updating a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *\n *   yield* Ref.update(counter, (n) => n * 2)\n *   return yield* Ref.get(counter)\n * })\n *\n * const program2 = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *   yield* Ref.update(counter, (n: number) => n + 10)\n *   return yield* Ref.get(counter)\n * })\n *\n * await Effect.runPromise(program) // => 10\n * await Effect.runPromise(program2) // => 15\n * ```\n *\n * @see {@link updateAndGet} for returning the new value\n * @see {@link getAndUpdate} for returning the previous value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const update = /*#__PURE__*/dual(2, (self, f) => Effect.sync(() => {\n  self.ref.current = f(self.ref.current);\n}));\n/**\n * Updates the value of the Ref atomically using the given function and returns the new value.\n *\n * **When to use**\n *\n * Use to apply a `Ref` state transition and return the new stored value.\n *\n * **Example** (Updating and returning the new value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *\n *   const newValue = yield* Ref.updateAndGet(counter, (n) => n * 3)\n *   const current = yield* Ref.get(counter)\n *   return [newValue, current]\n * })\n *\n * await Effect.runPromise(program) // => [15, 15]\n * ```\n *\n * @see {@link update} for updating without returning the new value\n * @see {@link getAndUpdate} for returning the previous value instead\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const updateAndGet = /*#__PURE__*/dual(2, (self, f) => Effect.sync(() => self.ref.current = f(self.ref.current)));\n/**\n * Updates the value of the Ref atomically using the given partial function.\n *\n * **When to use**\n *\n * Use to apply a conditional `Ref` update without returning a value.\n *\n * **Details**\n *\n * If the partial function returns `Option.some`, the Ref is updated with the\n * new value. If it returns `Option.none`, the Ref is left unchanged.\n *\n * **Example** (Conditionally updating a value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(5)\n *\n *   yield* Ref.updateSome(\n *     counter,\n *     (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()\n *   )\n *   const before = yield* Ref.get(counter)\n *   yield* Ref.set(counter, 6)\n *   yield* Ref.updateSome(\n *     counter,\n *     (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()\n *   )\n *   const after = yield* Ref.get(counter)\n *   return [before, after]\n * })\n *\n * await Effect.runPromise(program) // => [5, 12]\n * ```\n *\n * @see {@link update} for always applying an update\n * @see {@link updateSomeAndGet} for returning the resulting current value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const updateSome = /*#__PURE__*/dual(2, (self, f) => Effect.sync(() => {\n  const option = f(self.ref.current);\n  if (option._tag === \"Some\") {\n    self.ref.current = option.value;\n  }\n}));\n/**\n * Updates the value of the Ref atomically using the given partial function and returns the current value.\n *\n * **When to use**\n *\n * Use to apply a conditional `Ref` update and return the resulting current\n * value.\n *\n * **Details**\n *\n * If the partial function returns `Option.some`, the Ref is updated with the\n * new value. If it returns `Option.none`, the Ref is left unchanged. The effect\n * returns the current value of the Ref after the potential update.\n *\n * **Example** (Conditionally updating and returning the current value)\n *\n * ```ts import.meta.vitest\n * import { Effect, Option, Ref } from \"effect\"\n *\n * const program = Effect.gen(function*() {\n *   const counter = yield* Ref.make(10)\n *\n *   const result1 = yield* Ref.updateSomeAndGet(\n *     counter,\n *     (n) => n > 5 ? Option.some(n / 2) : Option.none()\n *   )\n *   const result2 = yield* Ref.updateSomeAndGet(\n *     counter,\n *     (n) => n > 5 ? Option.some(n / 2) : Option.none()\n *   )\n *   return [result1, result2]\n * })\n *\n * await Effect.runPromise(program) // => [5, 5]\n * ```\n *\n * @see {@link updateSome} for conditional updates without returning a value\n * @see {@link updateAndGet} for always updating and returning the new value\n *\n * @stability stable\n * @category mutations\n * @since 2.0.0\n */\nexport const updateSomeAndGet = /*#__PURE__*/dual(2, (self, pf) => Effect.sync(() => {\n  const option = pf(self.ref.current);\n  if (option._tag === \"Some\") {\n    self.ref.current = option.value;\n  }\n  return self.ref.current;\n}));\n/**\n * Gets the current value of the Ref synchronously (unsafe version).\n *\n * **When to use**\n *\n * Use when you need immediate synchronous access and can guarantee that\n * reading the `Ref` outside of `Effect` is safe.\n *\n * **Gotchas**\n *\n * Prefer `Ref.get` for Effect-wrapped access in Effect programs.\n *\n * **Example** (Reading a ref unsafely)\n *\n * ```ts import.meta.vitest\n * import { Ref } from \"effect\"\n *\n * const counter = Ref.makeUnsafe(42)\n * Ref.getUnsafe(counter) // => 42\n * ```\n *\n * @stability stable\n * @category getters\n * @since 4.0.0\n */\nexport const getUnsafe = self => self.ref.current;\n//# sourceMappingURL=Ref.js.map",
+    "import * as Arr from \"../Array.js\";\nimport * as Cause from \"../Cause.js\";\nimport * as Channel from \"../Channel.js\";\nimport * as ChannelSchema from \"../ChannelSchema.js\";\nimport * as Data from \"../Data.js\";\nimport * as Duration from \"../Duration.js\";\nimport * as Effect from \"../Effect.js\";\nimport { hasProperty } from \"../Predicate.js\";\nimport * as Pull from \"../Pull.js\";\nimport * as Result from \"../Result.js\";\nimport * as Schema from \"../Schema.js\";\nimport * as SchemaTransformation from \"../SchemaTransformation.js\";\nconst SseErrorTypeId = \"~effect/encoding/Sse/SseError\";\n/**\n * Error reason raised when pending Server-Sent Events state exceeds the\n * configured maximum size.\n *\n * @stability unstable\n * @category errors\n * @since 4.0.0\n */\nexport class EventTooLarge extends /*#__PURE__*/Data.TaggedError(\"EventTooLarge\") {\n  get message() {\n    return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;\n  }\n}\n/**\n * Error raised when decoding a Server-Sent Events stream fails.\n *\n * @stability unstable\n * @category errors\n * @since 4.0.0\n */\nexport class SseError extends /*#__PURE__*/Data.TaggedError(\"SseError\") {\n  /**\n   * Marks this value as an SSE decoding error.\n   *\n   * @stability unstable\n   * @since 4.0.0\n   */\n  [SseErrorTypeId] = SseErrorTypeId;\n  /**\n   * Delegates the public message to the underlying SSE error reason.\n   *\n   * @stability unstable\n   * @since 4.0.0\n   */\n  get message() {\n    return this.reason.message;\n  }\n}\nconst defaultMaxEventSize = 10 * 1024 * 1024;\n/**\n * Creates a channel that parses Server-Sent Events text chunks into `Event` values.\n *\n * **Details**\n *\n * SSE `retry` directives are emitted as `Retry` failures so callers can\n * reconnect with the requested delay.\n *\n * @stability unstable\n * @category decoding\n * @since 4.0.0\n */\nexport const decode = options => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {\n  let buffer = [];\n  let retry;\n  const parser = makeParser(event => {\n    if (event._tag === \"Retry\") {\n      retry = event;\n    } else {\n      buffer.push(event);\n    }\n  }, options);\n  const pump = Effect.flatMap(upstream, arr => {\n    for (let i = 0; i < arr.length; i++) {\n      const error = parser.feed(arr[i]);\n      if (error !== undefined) {\n        return Effect.fail(error);\n      }\n    }\n    return Effect.void;\n  });\n  return Effect.suspend(function loop() {\n    if (Arr.isArrayNonEmpty(buffer)) {\n      const out = buffer;\n      buffer = [];\n      return Effect.succeed(out);\n    } else if (retry) {\n      return Effect.fail(retry);\n    }\n    return Effect.flatMap(pump, loop);\n  });\n}));\n/**\n * Creates an SSE decoder channel that decodes each parsed event with a schema.\n *\n * **Details**\n *\n * The schema receives `{ event, data, id? }`, with string `data`. Absent IDs are\n * omitted, even with default options: use `Schema.optional(Schema.String)`, not\n * `Schema.UndefinedOr(Schema.String)`, to accept events without an ID.\n *\n * With `onExcessProperty: \"error\"`, declare `event` (default: `\"message\"`) and\n * `id` if the stream carries IDs, including inherited IDs.\n *\n * @stability unstable\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeSchema = (schema, options, parseOptions) => Channel.pipeTo(decode(options), ChannelSchema.decode(Event.pipe(Schema.decodeTo(schema, transformEvent)), parseOptions)());\n/**\n * Creates an SSE decoder channel that JSON-decodes each event `data` field with a schema.\n *\n * **Details**\n *\n * The output preserves the SSE `event` name and optional `id` while replacing\n * `data` with the decoded value.\n *\n * @stability unstable\n * @category decoding\n * @since 4.0.0\n */\nexport const decodeDataSchema = (schema, options) => {\n  const eventSchema = Schema.Struct({\n    ...EventEncoded.fields,\n    data: Schema.fromJsonString(schema)\n  });\n  return Channel.pipeTo(decode(options), Channel.map(ChannelSchema.decode(eventSchema)(), Arr.map(event => ({\n    ...event,\n    id: event.id\n  }))));\n};\n/**\n * Creates a stateful Server-Sent Events parser.\n *\n * **Details**\n *\n * Call `feed` with text chunks to parse `Event` and `Retry` values through the\n * callback, and call `reset` to clear any buffered event state. `feed` returns\n * an `SseError` if the pending event exceeds `maxEventSize`.\n *\n * @stability unstable\n * @category decoding\n * @since 4.0.0\n */\nexport function makeParser(onParse, options) {\n  const maxEventSize = options?.maxEventSize ?? defaultMaxEventSize;\n  const dispatchEmptyNamedEvents = options?.dispatchEmptyNamedEvents === true;\n  // Processing state\n  let isFirstChunk;\n  // Pieces of the unterminated line, joined once when the line ends\n  let pending;\n  let pendingLength;\n  let discardTrailingNewline;\n  // Incremented by `reset`, so `feed` can stop if `onParse` resets the parser\n  let generation = 0;\n  // Event state\n  let lastEventId;\n  let eventName;\n  let data;\n  reset();\n  return {\n    feed,\n    reset\n  };\n  function reset() {\n    generation++;\n    isFirstChunk = true;\n    pending = [];\n    pendingLength = 0;\n    discardTrailingNewline = false;\n    lastEventId = undefined;\n    eventName = undefined;\n    data = \"\";\n  }\n  function feed(chunk) {\n    // Empty chunks must not consume the leading BOM check below\n    if (chunk.length === 0) return;\n    // Strip a UTF-8 byte order mark (BOM) at the start of the stream\n    if (isFirstChunk && chunk.startsWith(BOM)) {\n      chunk = chunk.slice(BOM.length);\n    }\n    isFirstChunk = false;\n    const length = chunk.length;\n    const currentGeneration = generation;\n    let position = 0;\n    while (position < length) {\n      // Skip the LF of a CRLF, whose CR may have ended the previous chunk\n      if (discardTrailingNewline) {\n        discardTrailingNewline = false;\n        if (chunk.charCodeAt(position) === LF) {\n          ++position;\n          continue;\n        }\n      }\n      let lineEnd = position;\n      while (lineEnd < length) {\n        const code = chunk.charCodeAt(lineEnd);\n        if (code === CR || code === LF) break;\n        ++lineEnd;\n      }\n      if (lineEnd === length) {\n        pending.push(chunk.slice(position));\n        pendingLength += length - position;\n        break;\n      }\n      discardTrailingNewline = chunk.charCodeAt(lineEnd) === CR;\n      let line = chunk.slice(position, lineEnd);\n      if (pending.length > 0) {\n        pending.push(line);\n        line = pending.join(\"\");\n        pending = [];\n        pendingLength = 0;\n      }\n      parseLine(line);\n      if (generation !== currentGeneration) {\n        // `onParse` reset the parser, so drop the rest of this chunk\n        return;\n      }\n      position = lineEnd + 1;\n    }\n    if (pendingLength + data.length > maxEventSize) {\n      const error = new SseError({\n        reason: new EventTooLarge({\n          maxEventSize\n        })\n      });\n      reset();\n      return error;\n    }\n  }\n  function parseLine(line) {\n    if (line.length === 0) {\n      // End of event. Clear the state first so a throwing `onParse` cannot\n      // leak it into the next event\n      const named = eventName !== undefined && eventName !== \"\";\n      const event = eventName || \"message\";\n      const eventData = data;\n      eventName = undefined;\n      data = \"\";\n      if (eventData.length > 0 || dispatchEmptyNamedEvents && named) {\n        onParse({\n          _tag: \"Event\",\n          id: lastEventId,\n          event,\n          data: eventData.slice(0, -1) // remove trailing newline\n        });\n      }\n      return;\n    }\n    const colon = line.indexOf(\":\");\n    let field = line;\n    let value = \"\";\n    if (colon >= 0) {\n      field = line.slice(0, colon);\n      value = line.slice(line.charCodeAt(colon + 1) === SPACE ? colon + 2 : colon + 1);\n    }\n    if (field === \"data\") {\n      data += value + \"\\n\";\n    } else if (field === \"event\") {\n      eventName = value;\n    } else if (field === \"id\" && !value.includes(\"\\u0000\")) {\n      lastEventId = value;\n    } else if (field === \"retry\" && /^\\d+$/.test(value)) {\n      const retry = parseInt(value, 10);\n      onParse(new Retry({\n        duration: Duration.millis(retry),\n        lastEventId\n      }));\n    }\n  }\n}\nconst BOM = \"\\uFEFF\";\nconst LF = 10;\nconst CR = 13;\nconst SPACE = 32;\n/**\n * Creates a channel that encodes `Event` values as Server-Sent Events text.\n *\n * **Details**\n *\n * If the upstream channel fails with `Retry`, the retry directive is written and\n * the encoder completes.\n *\n * @stability unstable\n * @category encoding\n * @since 4.0.0\n */\nexport const encode = () => Channel.fromTransform((upstream, _scope) => Effect.sync(() => {\n  let done = false;\n  const pull = upstream.pipe(Effect.map(Arr.map(encoder.write)), Effect.catchFilter(Retry.filter, retry => {\n    done = true;\n    return Effect.succeed(Arr.of(encoder.write(retry)));\n  }), Pull.catchDone(() => Cause.done()));\n  return Effect.suspend(() => done ? Cause.done() : pull);\n}));\n/**\n * Creates an SSE encoder channel for values accepted by a schema.\n *\n * **Details**\n *\n * Values are schema-encoded to the untagged SSE event shape, transformed to\n * `Event`, and then written as Server-Sent Events text.\n *\n * @stability unstable\n * @category encoding\n * @since 4.0.0\n */\nexport const encodeSchema = schema => ChannelSchema.encode(Event.pipe(Schema.decodeTo(schema, transformEvent)))().pipe(Channel.pipeTo(encode()));\n/**\n * Schema for the untagged Server-Sent Events payload shape containing an optional `id`, `event`, and string `data` fields.\n *\n * @stability unstable\n * @category models\n * @since 4.0.0\n */\nexport const EventEncoded = /*#__PURE__*/Schema.Struct({\n  id: /*#__PURE__*/Schema.optional(Schema.String),\n  event: Schema.String,\n  data: Schema.String\n});\n/**\n * Schema for the tagged Server-Sent Events message model that adds `_tag: \"Event\"` to the event name, optional event ID, and string data payload.\n *\n * @stability unstable\n * @category models\n * @since 4.0.0\n */\nexport const Event = /*#__PURE__*/Schema.Struct({\n  _tag: /*#__PURE__*/Schema.tag(\"Event\"),\n  id: /*#__PURE__*/Schema.UndefinedOr(Schema.String),\n  event: Schema.String,\n  data: Schema.String\n});\n/**\n * Schema for transforming untagged SSE event payloads into tagged `Event`\n * models.\n *\n * @stability unstable\n * @category models\n * @since 4.0.0\n */\nexport const transformEvent = /*#__PURE__*/SchemaTransformation.transform({\n  decode: event => event.id === undefined ? {\n    event: event.event,\n    data: event.data\n  } : {\n    id: event.id,\n    event: event.event,\n    data: event.data\n  },\n  encode: event => ({\n    _tag: \"Event\",\n    id: event.id,\n    event: event.event ?? \"message\",\n    data: event.data\n  })\n});\nconst RetryTypeId = \"~effect/encoding/Sse/Retry\";\n/**\n * Represents a Server-Sent Events retry directive.\n *\n * **Details**\n *\n * Decoders surface this value as a failure to request reconnection after\n * `duration`; encoders serialize an upstream `Retry` failure as a `retry:` line.\n *\n * @stability unstable\n * @category models\n * @since 4.0.0\n */\nexport class Retry extends /*#__PURE__*/Data.TaggedClass(\"Retry\") {\n  /**\n   * Marks this value as an SSE retry directive for runtime guards.\n   *\n   * @stability unstable\n   * @since 4.0.0\n   */\n  [RetryTypeId] = RetryTypeId;\n  /**\n   * Returns `true` when the value is an SSE retry directive.\n   *\n   * @stability unstable\n   * @since 4.0.0\n   */\n  static is(u) {\n    return hasProperty(u, RetryTypeId);\n  }\n  /**\n   * Separates SSE retry directives from regular event values.\n   *\n   * @stability unstable\n   * @since 4.0.0\n   */\n  static filter(u) {\n    return Retry.is(u) ? Result.succeed(u) : Result.fail(u);\n  }\n}\n/**\n * Default Server-Sent Events encoder.\n *\n * **Details**\n *\n * It renders `Event` values as `id`, `event`, and `data` lines and renders\n * `Retry` values as `retry:` directives. CR and LF are removed from `id` and\n * `event`, and NUL is removed from `id`, so those values cannot inject fields\n * or events.\n *\n * @stability unstable\n * @category encoding\n * @since 4.0.0\n */\nexport const encoder = {\n  write(event) {\n    switch (event._tag) {\n      case \"Event\":\n        {\n          let data = \"\";\n          if (event.id !== undefined) {\n            data += `id: ${event.id.replace(/[\\r\\n\\0]/g, \"\")}\\n`;\n          }\n          if (event.event !== \"message\") {\n            data += `event: ${event.event.replace(/[\\r\\n]/g, \"\")}\\n`;\n          }\n          data += `data: ${event.data.replace(/\\r\\n|\\r|\\n/g, \"\\ndata: \")}\\n`;\n          return data + \"\\n\";\n        }\n      case \"Retry\":\n        {\n          return `retry: ${Duration.toMillis(event.duration)}\\n\\n`;\n        }\n    }\n  }\n};\n//# sourceMappingURL=Sse.js.map",
+    "import { __exportAll } from \"./_virtual/_rolldown/runtime.js\";\nimport { Event, Key, commandSchema } from \"./AgentChannel.js\";\nimport { Service } from \"./DualRuntime.js\";\nimport \"./AgentChannelConformance.js\";\nimport { Effect, Schema } from \"effect\";\n// src/AgentChannelConformance.ts\n/** Public replay conformance suite for channel plugins, runnable with @effect/vitest. */\nvar AgentChannelConformance_exports = /* @__PURE__ */ __exportAll({\n\tAgentChannelConformance: () => AgentChannelConformance_exports,\n\tConformanceError: () => ConformanceError,\n\tFixture: () => Fixture,\n\trun: () => run\n});\nconst Command = commandSchema(Schema.Json);\nconst Fixture = Schema.Struct({\n\tactivate: Command,\n\tchannelId: Key,\n\tconnectionId: Schema.optionalKey(Key),\n\tdeactivate: Command,\n\tdefinitionSettings: Schema.Json,\n\tdeliver: Command,\n\tdeploymentSettings: Schema.Json,\n\treceive: Command\n});\nvar ConformanceError = class extends Schema.TaggedError()(\"AgentChannelConformanceError\", {\n\tcommand: Schema.Literals([\n\t\t\"activate\",\n\t\t\"deactivate\",\n\t\t\"receive\",\n\t\t\"deliver\"\n\t]),\n\trule: Schema.Literals([\n\t\t\"command_kind\",\n\t\t\"stable_result\",\n\t\t\"stable_events\",\n\t\t\"boundary_rejection\"\n\t])\n}) {};\n/**\n* Replays operations that providers declare safe to replay. At-most-once delivery executes once;\n* the durable host owns its replay prohibition. Use an isolated provider test installation: this\n* suite performs provider effects. The host supplies stable keys; the plugin must recover the same\n* external subscription and emit the same provider event keys, even for a fresh receipt key.\n* Boundary rejection and feature/auth matrices are covered by the SDK's public runtime tests.\n*/\nconst run = Effect.fn(\"AgentChannelConformance.run\")(function* (input) {\n\tconst fixture = yield* Schema.decodeUnknownEffect(Fixture)(input, { onExcessProperty: \"error\" });\n\tconst runtime = yield* Service;\n\tconst definition = yield* runtime.getAgentChannel({ channelId: fixture.channelId });\n\tconst { activate, receive, deliver, deactivate, ...config } = fixture;\n\tconst { connectionId: _connectionId, ...withoutConnection } = config;\n\tconst probes = [\n\t\t{\n\t\t\tcode: \"invalid_input\",\n\t\t\tinput: {\n\t\t\t\t...config,\n\t\t\t\tchannelId: \"\",\n\t\t\t\tcommand: activate\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\tinput: {\n\t\t\t\t...config,\n\t\t\t\tchannelId: \"conformance/missing/channel\",\n\t\t\t\tcommand: activate\n\t\t\t},\n\t\t\tcode: \"not_found\"\n\t\t},\n\t\t{\n\t\t\tcode: \"invalid_input\",\n\t\t\tinput: {\n\t\t\t\t...config,\n\t\t\t\tcommand: {\n\t\t\t\t\t...activate,\n\t\t\t\t\toperationKey: \"\"\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\tcode: \"invalid_input\",\n\t\t\tinput: {\n\t\t\t\t...config,\n\t\t\t\tagent: { id: \"synthetic-authority\" },\n\t\t\t\tcommand: activate\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\tcode: \"invalid_auth\",\n\t\t\tinput: definition.authMethods.length === 0 ? {\n\t\t\t\t...config,\n\t\t\t\tcommand: activate,\n\t\t\t\tconnectionId: \"unexpected\"\n\t\t\t} : {\n\t\t\t\t...withoutConnection,\n\t\t\t\tcommand: activate\n\t\t\t}\n\t\t}\n\t];\n\tfor (const probe of probes) {\n\t\tconst outcome = yield* Effect.suspend(() => runtime.executeAgentChannel(probe.input)).pipe(Effect.result);\n\t\tif (outcome._tag !== \"Failure\" || outcome.failure.code !== probe.code) return yield* new ConformanceError({\n\t\t\tcommand: \"activate\",\n\t\t\trule: \"boundary_rejection\"\n\t\t});\n\t}\n\tconst commands = [\n\t\t[\"activate\", activate],\n\t\t[\"receive\", receive],\n\t\t[\"deliver\", deliver],\n\t\t[\"deactivate\", deactivate]\n\t];\n\tfor (const [kind, command] of commands) if (command.kind !== kind) return yield* new ConformanceError({\n\t\tcommand: kind,\n\t\trule: \"command_kind\"\n\t});\n\tconst activated = yield* Effect.acquireRelease(runtime.executeAgentChannel({\n\t\t...config,\n\t\tcommand: activate\n\t}), (result) => runtime.executeAgentChannel({\n\t\t...config,\n\t\tcommand: {\n\t\t\t...deactivate,\n\t\t\t...result.kind === \"activate\" ? {\n\t\t\t\tinstallationKey: result.installationKey,\n\t\t\t\tstate: result.state\n\t\t\t} : {}\n\t\t}\n\t}).pipe(Effect.orDie));\n\tfor (const [kind, command] of commands) {\n\t\tconst first = kind === \"activate\" ? activated : yield* runtime.executeAgentChannel({\n\t\t\t...config,\n\t\t\tcommand\n\t\t});\n\t\tif (kind === \"deliver\" && definition.features.deliveryMode === \"at-most-once\") continue;\n\t\tconst second = yield* runtime.executeAgentChannel({\n\t\t\t...config,\n\t\t\tcommand\n\t\t});\n\t\tconst firstJson = yield* Schema.decodeUnknownEffect(Schema.Json)(first);\n\t\tconst secondJson = yield* Schema.decodeUnknownEffect(Schema.Json)(second);\n\t\tif (!Schema.toEquivalence(Schema.Json)(firstJson, secondJson)) return yield* new ConformanceError({\n\t\t\tcommand: kind,\n\t\t\trule: \"stable_result\"\n\t\t});\n\t\tif (kind === \"receive\") {\n\t\t\tconst nextReceipt = yield* runtime.executeAgentChannel({\n\t\t\t\t...config,\n\t\t\t\tcommand: {\n\t\t\t\t\t...command,\n\t\t\t\t\toperationKey: `${command.operationKey.slice(0, 500)}:replay`\n\t\t\t\t}\n\t\t\t});\n\t\t\tif (first.kind !== \"receive\" || nextReceipt.kind !== \"receive\" || !Schema.toEquivalence(Schema.Array(Event))(first.events, nextReceipt.events)) return yield* new ConformanceError({\n\t\t\t\tcommand: kind,\n\t\t\t\trule: \"stable_events\"\n\t\t\t});\n\t\t}\n\t}\n}, Effect.scoped);\nexport { AgentChannelConformance_exports as AgentChannelConformance, AgentChannelConformance_exports, ConformanceError, Fixture, run };\n\n//# sourceMappingURL=AgentChannelConformance.js.map",
+    "import { __exportAll } from \"./_virtual/_rolldown/runtime.js\";\nimport \"./Mcp.js\";\nimport { Array, Boolean, Effect, MutableRef, Number, Option, Ref, Result, Schema, Stream, String, pipe } from \"effect\";\nimport { HttpClient, HttpClientRequest } from \"effect/http\";\nimport * as Sse from \"effect/encoding/Sse\";\n// src/Mcp.ts\n/**\n* A Model Context Protocol client over Streamable HTTP: the session generated plugins call tools\n* through and the CLI lists them with.\n*\n* @since 0.0.0\n*/\nvar Mcp_exports = /* @__PURE__ */ __exportAll({\n\tCallToolResult: () => CallToolResult,\n\tImplementation: () => Implementation,\n\tMcp: () => Mcp_exports,\n\tMcpError: () => McpError,\n\tTool: () => Tool,\n\tconnect: () => connect,\n\tlistTools: () => listTools\n});\n/**\n* A JSON-RPC error, SSE parsing error, or request that got no response.\n*\n* @since 0.0.0\n* @category errors\n*/\nvar McpError = class extends Schema.TaggedError()(\"McpError\", {\n\tcause: Schema.optional(Schema.Defect()),\n\tmessage: Schema.String\n}) {};\nconst protocolVersion = \"2025-06-18\";\nconst Implementation = Schema.Struct({\n\tname: Schema.String,\n\ttitle: Schema.optionalKey(Schema.String),\n\tversion: Schema.String\n});\nconst Tool = Schema.Struct({\n\tannotations: Schema.optionalKey(Schema.Struct({ title: Schema.optionalKey(Schema.String) })),\n\tdescription: Schema.optionalKey(Schema.String),\n\tinputSchema: Schema.Record(Schema.String, Schema.Unknown),\n\tname: Schema.String,\n\toutputSchema: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),\n\ttitle: Schema.optionalKey(Schema.String)\n});\nconst ListToolsResult = Schema.Struct({\n\tnextCursor: Schema.optionalKey(Schema.String),\n\ttools: Schema.Array(Tool)\n});\nconst ContentBlock = Schema.StructWithRest(Schema.Struct({\n\ttext: Schema.optionalKey(Schema.String),\n\ttype: Schema.String\n}), [Schema.Record(Schema.String, Schema.Unknown)]);\nconst CallToolResult = Schema.Struct({\n\tcontent: Schema.Array(ContentBlock),\n\tisError: Schema.optionalKey(Schema.Boolean),\n\tstructuredContent: Schema.optionalKey(Schema.Unknown)\n});\nconst InitializeResult = Schema.Struct({\n\tprotocolVersion: Schema.String,\n\tserverInfo: Implementation\n});\nconst Message = Schema.Struct({\n\terror: Schema.optionalKey(Schema.Struct({ message: Schema.String })),\n\tid: Schema.optionalKey(Schema.Unknown),\n\tresult: Schema.optionalKey(Schema.Unknown)\n});\nconst responseTo = Effect.fnUntraced(function* (id, method, response) {\n\tconst payloads = Boolean.match(pipe(response.headers[\"content-type\"] ?? \"\", String.startsWith(\"text/event-stream\")), {\n\t\tonFalse: () => Stream.fromEffect(response.text),\n\t\tonTrue: () => Stream.unwrap(Effect.sync(() => {\n\t\t\tconst events = MutableRef.make(Array.empty());\n\t\t\tconst parser = Sse.makeParser((event) => {\n\t\t\t\tif (event._tag === \"Event\") MutableRef.update(events, Array.append(event.data));\n\t\t\t});\n\t\t\treturn pipe(response.stream, Stream.decodeText(), Stream.mapEffect((chunk) => {\n\t\t\t\tconst error = parser.feed(chunk);\n\t\t\t\tif (error !== void 0) return Effect.fail(McpError.make({\n\t\t\t\t\tcause: error,\n\t\t\t\t\tmessage: error.message\n\t\t\t\t}));\n\t\t\t\tconst ready = MutableRef.get(events);\n\t\t\t\tMutableRef.set(events, Array.empty());\n\t\t\t\treturn Effect.succeed(ready);\n\t\t\t}), Stream.flatMap(Stream.fromIterable));\n\t\t}))\n\t});\n\tconst found = yield* pipe(payloads, Stream.filterMap((payload) => Result.fromOption(Option.filter(Schema.decodeOption(Schema.fromJsonString(Message))(payload), (message) => message.id === id && (message.result !== void 0 || message.error !== void 0)), () => payload)), Stream.runHead);\n\treturn yield* Effect.fromOption(found, () => McpError.make({ message: `${method} got no response` }));\n});\n/**\n* Opens a session with the server at `endpoint`: initializes it and returns its information and a\n* `request` that sends one JSON-RPC request and returns its result. Closing the scope ends the\n* session. `headers` carries the credentials the server asks for.\n*\n* @since 0.0.0\n* @category constructors\n*/\nconst connect = Effect.fn(\"Mcp.connect\")(function* (client, endpoint, headers) {\n\tconst checked = HttpClient.filterStatusOk(client);\n\tconst post = Effect.fnUntraced(function* (version, session, body) {\n\t\treturn yield* checked.execute(pipe(HttpClientRequest.post(endpoint), HttpClientRequest.setHeaders({\n\t\t\t...headers,\n\t\t\taccept: \"application/json, text/event-stream\",\n\t\t\t\"mcp-protocol-version\": version,\n\t\t\t...Option.match(session, {\n\t\t\t\tonNone: () => ({}),\n\t\t\t\tonSome: (id) => ({ \"mcp-session-id\": id })\n\t\t\t})\n\t\t}), HttpClientRequest.bodyJsonUnsafe({\n\t\t\tjsonrpc: \"2.0\",\n\t\t\t...body\n\t\t})));\n\t});\n\tconst call = Effect.fnUntraced(function* (version, session, id, method, params) {\n\t\tconst response = yield* post(version, session, {\n\t\t\tid,\n\t\t\tmethod,\n\t\t\tparams\n\t\t});\n\t\tconst message = yield* responseTo(id, method, response);\n\t\tif (message.error !== void 0) return yield* McpError.make({ message: `${method}: ${message.error.message}` });\n\t\treturn {\n\t\t\tresult: message.result,\n\t\t\tsession: Option.orElse(Option.fromNullishOr(response.headers[\"mcp-session-id\"]), () => session)\n\t\t};\n\t});\n\tconst negotiatedVersion = yield* Ref.make(protocolVersion);\n\tconst initialized = yield* Effect.acquireRelease(call(protocolVersion, Option.none(), 0, \"initialize\", {\n\t\tcapabilities: {},\n\t\tclientInfo: {\n\t\t\tname: \"dual\",\n\t\t\tversion: \"1\"\n\t\t},\n\t\tprotocolVersion\n\t}), (opened) => Option.match(opened.session, {\n\t\tonNone: () => Effect.void,\n\t\tonSome: (id) => Effect.flatMap(Ref.get(negotiatedVersion), (version) => Effect.ignore(client.execute(pipe(HttpClientRequest.delete(endpoint), HttpClientRequest.setHeaders({\n\t\t\t...headers,\n\t\t\t\"mcp-protocol-version\": version,\n\t\t\t\"mcp-session-id\": id\n\t\t})))))\n\t}));\n\tconst server = yield* Schema.decodeUnknownEffect(InitializeResult)(initialized.result);\n\tif (server.protocolVersion !== protocolVersion && server.protocolVersion !== \"2025-03-26\") return yield* McpError.make({ message: `Unsupported MCP protocol version ${server.protocolVersion}` });\n\tyield* Ref.set(negotiatedVersion, server.protocolVersion);\n\tyield* post(server.protocolVersion, initialized.session, { method: \"notifications/initialized\" });\n\tconst ids = yield* Ref.make(1);\n\treturn {\n\t\trequest: Effect.fn(\"Mcp.request\")(function* (method, params) {\n\t\t\treturn (yield* call(server.protocolVersion, initialized.session, yield* Ref.getAndUpdate(ids, Number.increment), method, params)).result;\n\t\t}),\n\t\tserver: server.serverInfo\n\t};\n});\n/**\n* Lists every tool of the server at `endpoint`, following its pages, in a session of its own.\n*\n* @since 0.0.0\n* @category constructors\n*/\nconst listTools = Effect.fn(\"Mcp.listTools\")(function* (client, endpoint, headers) {\n\tconst session = yield* connect(client, endpoint, headers);\n\tconst tools = yield* Stream.runCollect(Stream.paginate({}, Effect.fnUntraced(function* (params) {\n\t\tconst page = yield* Schema.decodeUnknownEffect(ListToolsResult)(yield* session.request(\"tools/list\", params));\n\t\treturn [page.tools, Option.map(Option.fromUndefinedOr(page.nextCursor), (cursor) => ({ cursor }))];\n\t})));\n\treturn {\n\t\tserver: session.server,\n\t\ttools\n\t};\n}, Effect.scoped);\nexport { CallToolResult, Implementation, Mcp_exports as Mcp, McpError, Mcp_exports, Tool, connect, listTools };\n\n//# sourceMappingURL=Mcp.js.map",
+    "import { __exportAll } from \"./_virtual/_rolldown/runtime.js\";\nimport { ActionHandlerError, fromHttpClientFailure } from \"./Action.js\";\nimport { Schema as Schema$1 } from \"./ToolFile.js\";\nimport { File as File$1, read as read$1, write } from \"./Files.js\";\nimport { CallToolResult, McpError, connect } from \"./Mcp.js\";\nimport \"./Http.js\";\nimport { Array, Boolean, DateTime, Effect, Equal, Option, Order, Predicate, Random, Record, Result, Schema, SchemaGetter, SchemaIssue, String, flow, pipe } from \"effect\";\nimport { FetchHttpClient, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, UrlParams } from \"effect/http\";\nimport { Base64, Base64Url } from \"effect/encoding\";\n// src/Http.ts\n/**\n* The HTTP runtime of generated API plugins: each operation's contract and call, request encoding,\n* response decoding, continuation links, redirects and uploads.\n*\n* @since 0.0.0\n*/\nvar Http_exports = /* @__PURE__ */ __exportAll({\n\tBase64FromFile: () => Base64FromFile,\n\tBase64UrlFromFile: () => Base64UrlFromFile,\n\tDataUriFromFile: () => DataUriFromFile,\n\tDateTimeFromRfc2822: () => DateTimeFromRfc2822,\n\tDateTimeFromUnixSeconds: () => DateTimeFromUnixSeconds,\n\tFile: () => File,\n\tFileFromBase64: () => FileFromBase64,\n\tFileFromBase64Url: () => FileFromBase64Url,\n\tFileFromDataUri: () => FileFromDataUri,\n\tHttp: () => Http_exports,\n\tRfc2822FromDateTime: () => Rfc2822FromDateTime,\n\tUnixSecondsFromDateTime: () => UnixSecondsFromDateTime,\n\tcontinuation: () => continuation,\n\tdecoded: () => decoded,\n\tform: () => form,\n\tliteral: () => literal,\n\tmake: () => make,\n\tparams: () => params,\n\tpath: () => path,\n\tpreauthenticated: () => preauthenticated,\n\tsegments: () => segments,\n\twithFile: () => withFile,\n\twithForm: () => withForm\n});\nfunction preserveJsonProperties(value, input) {\n\tif (Equal.equals(value, input)) return value;\n\tif (Array.isArray(value) && Array.isArray(input)) for (const entry of Array.zip(value, input)) preserveJsonProperties(entry[0], entry[1]);\n\telse if (Predicate.isObject(value) && Predicate.isObject(input)) for (const entry of Record.toEntries(input)) if (Record.has(value, entry[0])) preserveJsonProperties(value[entry[0]], entry[1]);\n\telse Object.defineProperty(value, entry[0], {\n\t\tconfigurable: true,\n\t\tenumerable: true,\n\t\tvalue: entry[1],\n\t\twritable: true\n\t});\n\treturn value;\n}\nfunction decodeResponse(output) {\n\treturn flow(Effect.succeed, Effect.flatMap((input) => pipe(Schema.decodeUnknownEffect(output)(input), Effect.map((value) => preserveJsonProperties(value, input)))));\n}\nconst File = Schema.Struct({\n\t_tag: Schema.optionalKey(Schema.Literal(\"ToolFile\")),\n\tcontentBase64: Schema.Uint8ArrayFromBase64,\n\tcontentType: Schema.optionalKey(Schema.NullOr(Schema.String)),\n\tfilename: Schema.optionalKey(Schema.NullOr(Schema.String)),\n\tsizeBytes: Schema.optionalKey(Schema.Natural)\n}).annotate({ description: \"A ToolFile, such as the result of a download, passed unchanged; or its contentBase64 with an optional contentType and filename.\" });\nconst signatures = [\n\t[\"image/jpeg\", [[0, [\n\t\t255,\n\t\t216,\n\t\t255\n\t]]]],\n\t[\"image/png\", [[0, [\n\t\t137,\n\t\t80,\n\t\t78,\n\t\t71\n\t]]]],\n\t[\"image/gif\", [[0, [\n\t\t71,\n\t\t73,\n\t\t70,\n\t\t56\n\t]]]],\n\t[\"image/webp\", [[0, [\n\t\t82,\n\t\t73,\n\t\t70,\n\t\t70\n\t]], [8, [\n\t\t87,\n\t\t69,\n\t\t66,\n\t\t80\n\t]]]],\n\t[\"application/pdf\", [[0, [\n\t\t37,\n\t\t80,\n\t\t68,\n\t\t70\n\t]]]],\n\t[\"application/zip\", [[0, [\n\t\t80,\n\t\t75,\n\t\t3,\n\t\t4\n\t]]]]\n];\nconst utf8 = new TextDecoder(\"utf-8\", { fatal: true });\nfunction sniff(bytes) {\n\treturn pipe(Array.findFirst(signatures, (signature) => Array.every(signature[1], (part) => Array.every(part[1], (byte, index) => bytes[part[0] + index] === byte))), Option.map((signature) => signature[0]), Option.orElse(() => Option.liftPredicate(\"text/plain\", () => Result.isSuccess(Result.try(() => utf8.decode(bytes))))), Option.getOrNull);\n}\nfunction toolFile(bytes, declared, filename) {\n\treturn {\n\t\t_tag: \"ToolFile\",\n\t\tcontentBase64: Base64.encode(bytes),\n\t\tcontentType: declared === null || pipe(declared, String.startsWith(\"application/octet-stream\")) ? sniff(bytes) ?? declared : declared,\n\t\tfilename,\n\t\tsizeBytes: bytes.byteLength\n\t};\n}\nfunction invalid(expected, value, options) {\n\treturn Effect.fail(new SchemaIssue.InvalidValue({ expected }, value, options));\n}\nfunction decodeBytes(text, options) {\n\treturn Result.match(Base64Url.decode(pipe(text, String.replaceAll(\"+\", \"-\"), String.replaceAll(\"/\", \"_\"))), {\n\t\tonFailure: () => invalid(\"a Base64 or Base64Url string\", text, options),\n\t\tonSuccess: (bytes) => Effect.succeed(bytes)\n\t});\n}\nfunction contentOf(carrier) {\n\treturn SchemaGetter.transformEffect((text, options) => {\n\t\tif (carrier !== \"data-uri\") return Effect.map(decodeBytes(text, options), (bytes) => ({\n\t\t\tbytes,\n\t\t\tcontentType: null\n\t\t}));\n\t\treturn Option.match(pipe(text, String.match(/^data:([^;,]*)(?:;[^;,]*)*;base64,(.*)$/su)), {\n\t\t\tonNone: () => invalid(\"a Base64 data URI\", text, options),\n\t\t\tonSome: (parts) => Effect.map(decodeBytes(Array.getUnsafe(parts, 2), options), (bytes) => ({\n\t\t\t\tbytes,\n\t\t\t\tcontentType: pipe(Array.getUnsafe(parts, 1), Option.liftPredicate(String.isNonEmpty), Option.getOrNull)\n\t\t\t}))\n\t\t});\n\t});\n}\nfunction textOf(carrier, content) {\n\tif (carrier === \"base64\") return Base64.encode(content.bytes);\n\tif (carrier === \"base64url\") return Base64Url.encode(content.bytes);\n\treturn `data:${content.contentType ?? sniff(content.bytes) ?? \"application/octet-stream\"};base64,${Base64.encode(content.bytes)}`;\n}\nfunction fileFrom(carrier) {\n\treturn Schema.String.pipe(Schema.decodeTo(Schema$1, {\n\t\tdecode: SchemaGetter.compose(contentOf(carrier), SchemaGetter.transform((content) => toolFile(content.bytes, content.contentType, null))),\n\t\tencode: SchemaGetter.transformEffect((file, options) => Effect.map(decodeBytes(file.contentBase64, options), (bytes) => textOf(carrier, {\n\t\t\tbytes,\n\t\t\tcontentType: file.contentType\n\t\t})))\n\t}));\n}\nfunction encodedFrom(carrier) {\n\treturn File.pipe(Schema.decodeTo(Schema.String, {\n\t\tdecode: SchemaGetter.transform((file) => textOf(carrier, {\n\t\t\tbytes: file.contentBase64,\n\t\t\tcontentType: file.contentType ?? null\n\t\t})),\n\t\tencode: SchemaGetter.compose(contentOf(carrier), SchemaGetter.transform((content) => ({\n\t\t\tcontentBase64: content.bytes,\n\t\t\tcontentType: content.contentType\n\t\t})))\n\t}));\n}\n/**\n* A file the API returns as a Base64 string inside JSON, decoded into a ToolFile with its content\n* type recognized from the bytes.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst FileFromBase64 = fileFrom(\"base64\");\n/**\n* {@link FileFromBase64} for an API that writes the file in Base64Url.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst FileFromBase64Url = fileFrom(\"base64url\");\n/**\n* A {@link File} input the API reads as a Base64 string inside JSON.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst Base64FromFile = encodedFrom(\"base64\");\n/**\n* {@link Base64FromFile} for an API that reads the file in Base64Url.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst Base64UrlFromFile = encodedFrom(\"base64url\");\n/**\n* {@link FileFromBase64} for an API that writes the file as a data URI, which also carries its\n* content type.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst FileFromDataUri = fileFrom(\"data-uri\");\n/**\n* {@link Base64FromFile} for an API that reads the file as a data URI, built from the file's\n* content type.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst DataUriFromFile = encodedFrom(\"data-uri\");\nconst DateTimeText = Schema.String.annotate({ format: \"date-time\" });\nconst rfc3339 = /^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2})(?:\\.\\d+)?(?:Z|([+-]\\d{2}:\\d{2}))$/u;\n/** The instant of an RFC 3339 date-time with its offset; an impossible date such as February 30 has none. */\nfunction rfc3339Instant(text) {\n\treturn pipe(Option.fromNullishOr(rfc3339.exec(text)), Option.flatMap((match) => Option.filter(DateTime.makeZoned(text, { timeZone: match[2] ?? \"+00:00\" }), (zoned) => String.startsWith(match[1] ?? \"\")(DateTime.formatIsoOffset(zoned)))), Option.map(DateTime.toUtc));\n}\nfunction instants(wire, expected, read, write) {\n\tconst fromWire = SchemaGetter.transformEffect((value, options) => Option.match(read(value), {\n\t\tonNone: () => invalid(expected, value, options),\n\t\tonSome: (instant) => Effect.succeed(DateTime.formatIso(instant))\n\t}));\n\tconst toWire = SchemaGetter.transformEffect((text, options) => Option.match(rfc3339Instant(text), {\n\t\tonNone: () => invalid(\"an ISO 8601 date-time\", text, options),\n\t\tonSome: (instant) => Effect.succeed(write(instant))\n\t}));\n\treturn {\n\t\tinput: pipe(DateTimeText, Schema.decodeTo(wire, {\n\t\t\tdecode: toWire,\n\t\t\tencode: fromWire\n\t\t})),\n\t\toutput: pipe(wire, Schema.decodeTo(DateTimeText, {\n\t\t\tdecode: fromWire,\n\t\t\tencode: toWire\n\t\t}))\n\t};\n}\nconst unixSeconds = instants(Schema.Int, \"Unix seconds\", (seconds) => Option.map(DateTime.make(seconds * 1e3), DateTime.toUtc), (instant) => Math.floor(DateTime.toEpochMillis(instant) / 1e3));\nconst rfc2822 = instants(Schema.String, \"an RFC 2822 date-time\", (text) => Option.map(DateTime.make(text), DateTime.toUtc), (instant) => DateTime.toDateUtc(instant).toUTCString());\n/**\n* A date-time the API writes as Unix seconds, decoded into an ISO 8601 UTC string.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst DateTimeFromUnixSeconds = unixSeconds.output;\n/**\n* An ISO 8601 date-time input the API reads as Unix seconds.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst UnixSecondsFromDateTime = unixSeconds.input;\n/**\n* A date-time the API writes in RFC 2822 form, decoded into an ISO 8601 UTC string.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst DateTimeFromRfc2822 = rfc2822.output;\n/**\n* An ISO 8601 date-time input the API reads in RFC 2822 form.\n*\n* @since 0.0.0\n* @category schemas\n*/\nconst Rfc2822FromDateTime = rfc2822.input;\n/**\n* Declares an output by the response schema it decodes from; see {@link Decoded}.\n*\n* @since 0.0.0\n* @category constructors\n*/\nfunction decoded(wire) {\n\treturn {\n\t\t_tag: \"Decoded\",\n\t\twire\n\t};\n}\nconst GraphqlResponse = Schema.Struct({\n\tdata: Schema.optionalKey(Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown))),\n\terrors: Schema.optionalKey(Schema.Array(Schema.StructWithRest(Schema.Struct({ message: Schema.String }), [Schema.Record(Schema.String, Schema.Unknown)])))\n});\nfunction coerce(value) {\n\treturn Predicate.isObject(value) ? JSON.stringify(value) : `${value}`;\n}\n/**\n* Encodes a path parameter as one segment.\n*\n* @since 0.0.0\n* @category encoding\n*/\nfunction path(value) {\n\treturn encodeURIComponent(coerce(value));\n}\n/**\n* Encodes a path parameter written inside single quotes, an OData string literal, doubling its\n* quotes: `O'Brien` in `People('{name}')` is sent as `People('O''Brien')`.\n*\n* @since 0.0.0\n* @category encoding\n*/\nfunction literal(value) {\n\treturn path(pipe(coerce(value), String.replaceAll(\"'\", \"''\")));\n}\n/**\n* Encodes a path parameter whose slashes stay path separators.\n*\n* @since 0.0.0\n* @category encoding\n*/\nfunction segments(value) {\n\treturn Array.join(Array.map(String.split(coerce(value), \"/\"), encodeURIComponent), \"/\");\n}\nfunction deepObject(name, value) {\n\tif (Array.isArray(value)) return Array.flatMap(value, (item, index) => deepObject(`${name}[${index}]`, item));\n\tif (Predicate.isObject(value)) return Array.flatMap(Record.toEntries(value), (entry) => deepObject(`${name}[${entry[0]}]`, entry[1]));\n\treturn value === void 0 ? [] : [[name, coerce(value)]];\n}\n/**\n* Query, header or form entries, repeating array values unless their name is joined, and encoding\n* `deep` names as bracketed keys such as `metadata[plan]` and `expand[0]`. A joined name is\n* comma-separated, or separated by the delimiter it is paired with, such as `[\"ids\", \"|\"]`.\n* `exploded` object parameters use their property names as query keys (`role=vet&active=true`).\n*\n* @since 0.0.0\n* @category encoding\n*/\nfunction params(fields, joined = [], deep = [], exploded = []) {\n\treturn Array.flatMap(Record.toEntries(fields), (field) => {\n\t\tif (field[1] === void 0) return [];\n\t\tif (Array.contains(deep, field[0])) return deepObject(field[0], field[1]);\n\t\tconst values = field[1];\n\t\tif (Array.contains(exploded, field[0]) && Predicate.isObject(values) && !Array.isArray(values)) return Array.filterMap(Record.toEntries(values), (entry) => entry[1] === void 0 ? Result.failVoid : Result.succeed([entry[0], coerce(entry[1])]));\n\t\tif (!Array.isArray(values)) return [[field[0], coerce(values)]];\n\t\tconst separator = Array.findFirst(joined, (entry) => {\n\t\t\tconst pair = Predicate.isString(entry) ? [entry, \",\"] : entry;\n\t\t\treturn pair[0] === field[0] ? Option.some(pair[1]) : Option.none();\n\t\t});\n\t\treturn Option.match(separator, {\n\t\t\tonNone: () => Array.map(values, (item) => [field[0], coerce(item)]),\n\t\t\tonSome: (value) => [[field[0], Array.join(Array.map(values, coerce), value)]]\n\t\t});\n\t});\n}\nfunction filePart(bytes, name, contentType) {\n\treturn new globalThis.File([new Uint8Array(bytes)], name, { type: contentType });\n}\n/**\n* Multipart form fields, sending each {@link File} as a file part.\n*\n* @since 0.0.0\n* @category encoding\n*/\nfunction form(payload) {\n\treturn Record.map(payload, (value, name) => Array.map(Array.ensure(value), (item) => {\n\t\tif (item === void 0) return void 0;\n\t\tif (!Schema.is(File)(item)) return coerce(item);\n\t\treturn filePart(item.contentBase64, item.filename ?? name, item.contentType ?? \"application/octet-stream\");\n\t}));\n}\nfunction fileFailed(error) {\n\treturn ActionHandlerError.make({\n\t\tcause: error,\n\t\tmessage: error.message\n\t});\n}\nfunction readFile(file) {\n\treturn pipe(read$1(file), Effect.mapError(fileFailed));\n}\n/**\n* Sends a file as the raw request body.\n*\n* @since 0.1.0\n* @category encoding\n*/\nconst withFile = Effect.fnUntraced(function* (request, file) {\n\treturn HttpClientRequest.bodyUint8Array(request, yield* readFile(file), file.contentType);\n});\n/**\n* Sends multipart form fields, each {@link Files.File} as a file part.\n*\n* @since 0.1.0\n* @category encoding\n*/\nconst withForm = Effect.fnUntraced(function* (request, payload) {\n\treturn HttpClientRequest.bodyFormDataRecord(request, Record.fromEntries(yield* Effect.forEach(Record.toEntries(payload), (field) => Effect.map(Effect.forEach(Array.filter(Array.ensure(field[1]), (item) => item !== void 0), (item) => Effect.gen(function* () {\n\t\tif (!Schema.is(File$1)(item)) return coerce(item);\n\t\treturn filePart(yield* readFile(item), item.name, item.contentType);\n\t})), (parts) => [field[0], parts]))));\n});\nfunction mediaBytes(media) {\n\tif (Schema.is(File$1)(media)) return Effect.map(readFile(media), (bytes) => ({\n\t\tbytes,\n\t\tcontentType: media.contentType\n\t}));\n\treturn Effect.succeed({\n\t\tbytes: media.contentBase64,\n\t\tcontentType: Option.getOrNull(Option.fromNullishOr(media.contentType))\n\t});\n}\nfunction isSafeUrl(value, origin) {\n\tif (!URL.canParse(value)) return false;\n\tconst url = new URL(value);\n\treturn url.protocol === \"https:\" && url.username === \"\" && url.password === \"\" && (origin === void 0 || url.origin === origin);\n}\nfunction refused(message) {\n\treturn Effect.fail(ActionHandlerError.make({ message }));\n}\n/**\n* Follows a returned next-page link on the operation's own origin: only its path and query are\n* taken, so the connection's host routing applies and credentials never reach another host.\n*\n* @since 0.0.0\n* @category requests\n*/\nfunction continuation(request, nextLink) {\n\tif (nextLink === void 0) return Effect.succeed(request);\n\tconst declared = new URL(request.url);\n\tconst next = URL.canParse(nextLink) ? new URL(nextLink) : void 0;\n\tif (next === void 0 || !isSafeUrl(nextLink) || next.pathname !== declared.pathname) return refused(\"A continuation URL must be an HTTPS link to the same operation path\");\n\treturn Effect.succeed(HttpClientRequest.makeWith(request.method, `${declared.origin}${next.pathname}${next.search}`, UrlParams.empty, Option.none(), request.headers, HttpBody.empty));\n}\n/**\n* A request to a preauthenticated upload URL, which is sent without the connection's credentials.\n*\n* @since 0.0.0\n* @category requests\n*/\nfunction preauthenticated(method, url, ...steps) {\n\tif (!isSafeUrl(url)) return refused(\"An upload session requires a preauthenticated HTTPS URL\");\n\treturn Effect.succeed(Array.reduce(steps, method(url), (request, step) => step(request)));\n}\nfunction failure(error) {\n\treturn Schema.is(ActionHandlerError)(error) ? error : fromHttpClientFailure(error);\n}\nfunction redirect(response) {\n\tconst location = response.headers[\"location\"];\n\tif (response.status < 300 || response.status >= 400 || location === void 0) return void 0;\n\tconst sent = response.request;\n\tconst url = new URL(location, sent.url);\n\tconst request = response.status === 303 && sent.method !== \"GET\" && sent.method !== \"HEAD\" || (response.status === 301 || response.status === 302) && sent.method === \"POST\" ? HttpClientRequest.setBody(HttpClientRequest.setMethod(sent, \"GET\"), HttpBody.empty) : sent;\n\treturn url.origin === new URL(sent.url).origin ? HttpClientRequest.setUrl(request, url) : HttpClientRequest.setUrl(HttpClientRequest.makeWith(request.method, \"\", UrlParams.empty, Option.none(), Headers.empty, request.body), url);\n}\nfunction follow(client, response, redirects) {\n\tconst next = redirect(response);\n\treturn next === void 0 || redirects === 10 ? Effect.succeed(response) : Effect.flatMap(client.execute(next), (result) => follow(client, result, redirects + 1));\n}\n/** The file name a `Content-Disposition` header suggests, preferring its encoded form. */\nfunction dispositionName(header) {\n\tif (header === void 0) return void 0;\n\tconst encoded = pipe(String.match(/(?:^|;)\\s*filename\\*\\s*=\\s*UTF-8'[^']*'([^;]+)/iu)(header), Option.flatMap((match) => Option.fromUndefinedOr(match[1])));\n\tconst decoded = pipe(encoded, Option.flatMap((value) => Option.liftThrowable(() => decodeURIComponent(String.trim(value)))()));\n\treturn Option.getOrElse(decoded, () => pipe(String.match(/(?:^|;)\\s*filename\\s*=\\s*(?:\"((?:\\\\.|[^\"\\\\])*)\"|([^;]*))/iu)(header), Option.flatMap((match) => Option.orElse(Option.map(Option.fromUndefinedOr(match[1]), (name) => String.replace(/\\\\(.)/gu, \"$1\")(name)), () => Option.map(Option.fromUndefinedOr(match[2]), String.trim))), Option.getOrUndefined));\n}\nconst read = Effect.fnUntraced(function* (response, body) {\n\tif (body === \"json\") return yield* response.json;\n\tif (body === \"text\") return yield* response.text;\n\tif (body === \"void\") return {};\n\tif (body === \"unknown\") {\n\t\tconst text = yield* response.text;\n\t\tif (String.isEmpty(String.trim(text))) return null;\n\t\treturn Option.getOrElse(Schema.decodeOption(Schema.fromJsonString(Schema.Json))(text), () => text);\n\t}\n\tconst bytes = new Uint8Array(yield* response.arrayBuffer);\n\tconst name = dispositionName(response.headers[\"content-disposition\"]);\n\tif (body === \"file\") return yield* pipe(write({\n\t\tbytes,\n\t\tcontentType: Option.getOrNull(Option.fromUndefinedOr(response.headers[\"content-type\"])),\n\t\tname: name ?? \"file\"\n\t}), Effect.mapError(fileFailed));\n\treturn toolFile(bytes, response.headers[\"content-type\"] ?? null, name ?? null);\n});\n/**\n* Binds the runtime to a package's auth module: the calls a generated version file makes. Its\n* `authorize` applies a connection's credentials to the client. Its optional `checkResponse` fails\n* a successful response that reports a failed call, such as Slack's `{ ok: false, error }`.\n* `preauthenticatedUploadUrl` restricts credential-free upload requests and every redirect to\n* provider-approved HTTPS URLs, without changing authenticated calls or other providers.\n*\n* @since 0.0.0\n* @category constructors\n*/\nfunction make(auth) {\n\tconst { authorize, checkResponse = () => Effect.void } = auth;\n\tconst send = Effect.fnUntraced(function* (context, request) {\n\t\tconst base = yield* HttpClient.HttpClient;\n\t\tconst uploadPolicy = context === void 0 ? auth.preauthenticatedUploadUrl : void 0;\n\t\tconst client = uploadPolicy === void 0 ? base : HttpClient.mapRequestEffect(base, (outgoing) => isSafeUrl(outgoing.url) && Schema.is(uploadPolicy)(outgoing.url) ? Effect.succeed(outgoing) : Effect.fail(new HttpClientError.HttpClientError({ reason: new HttpClientError.InvalidUrlError({\n\t\t\tdescription: \"The upload URL is not an approved provider HTTPS destination\",\n\t\t\trequest: outgoing\n\t\t}) })));\n\t\tconst transport = HttpClient.transformResponse(client, Effect.flatMap((response) => follow(client, response, 0)));\n\t\tconst execution = (context === void 0 ? transport : authorize(transport, context)).execute(Effect.isEffect(request) ? yield* request : request);\n\t\tconst options = yield* Effect.serviceOption(FetchHttpClient.RequestInit);\n\t\tconst response = yield* Boolean.match(uploadPolicy !== void 0, {\n\t\t\tonFalse: () => execution,\n\t\t\tonTrue: () => Effect.provideService(execution, FetchHttpClient.RequestInit, {\n\t\t\t\t...Option.getOrElse(options, () => ({})),\n\t\t\t\tredirect: \"manual\"\n\t\t\t})\n\t\t});\n\t\tif (response.status < 200 || response.status >= 300) return yield* Effect.fail({\n\t\t\tcause: yield* response.text,\n\t\t\tresponse\n\t\t});\n\t\tyield* checkResponse(response);\n\t\treturn response;\n\t});\n\tfunction endpoint(contract, run) {\n\t\tif (!Schema.isSchema(contract.output)) {\n\t\t\tconst wire = contract.output.wire;\n\t\t\treturn {\n\t\t\t\tinput: contract.input,\n\t\t\t\toutput: Schema.toType(wire),\n\t\t\t\trun: (input, context) => run(input, context, wire),\n\t\t\t\twire\n\t\t\t};\n\t\t}\n\t\tconst output = contract.output;\n\t\treturn {\n\t\t\tinput: contract.input,\n\t\t\toutput,\n\t\t\trun: (input, context) => run(input, context, output)\n\t\t};\n\t}\n\t/** Sends a request and decodes its body as the operation's single response. */\n\tfunction execute(context, output, request, body) {\n\t\treturn pipe(send(context, request), Effect.flatMap((response) => read(response, body)), Effect.flatMap(decodeResponse(output)), Effect.mapError(failure));\n\t}\n\t/** Sends a request and decodes the declared response variant its status and media type select. */\n\tconst variants = Effect.fnUntraced(function* (context, output, request, declared, media) {\n\t\tconst response = yield* send(context, request);\n\t\tconst exact = Array.flatMap(declared, (variant) => variant.status === void 0 ? [] : [variant.status]);\n\t\tconst contentType = pipe(response.headers[\"content-type\"] ?? \"\", String.split(\";\"), Array.headNonEmpty, String.trim, String.toLowerCase);\n\t\tconst ordered = Array.sort(declared, Order.mapInput(Order.Number, (variant) => {\n\t\t\tif (variant.body === \"void\" || variant.body === \"unknown\") return 3;\n\t\t\tif (variant.contentType === \"*/*\") return 2;\n\t\t\treturn pipe(variant.contentType, String.endsWith(\"/*\")) ? 1 : 0;\n\t\t}));\n\t\tconst variant = Array.findFirst(ordered, (candidate) => {\n\t\t\tif (!(candidate.status === void 0 ? !Array.contains(exact, response.status) : candidate.status === response.status)) return false;\n\t\t\tif (media !== void 0) return (candidate.body === \"binary\" || candidate.body === \"file\") === media;\n\t\t\tif (candidate.body === \"void\" || candidate.body === \"unknown\" || candidate.contentType === \"*/*\") return true;\n\t\t\tif (pipe(candidate.contentType, String.endsWith(\"/*\"))) return pipe(contentType, String.startsWith(pipe(candidate.contentType, String.slice(0, -1))));\n\t\t\treturn contentType === candidate.contentType;\n\t\t});\n\t\tif (Option.isNone(variant)) return yield* Effect.fail({\n\t\t\tcause: \"The API returned an undeclared successful response\",\n\t\t\tresponse\n\t\t});\n\t\tconst headers = Array.flatMap(variant.value.headers ?? [], (name) => {\n\t\t\tconst value = response.headers[String.toLowerCase(name)];\n\t\t\treturn value === void 0 ? [] : [[name, value]];\n\t\t});\n\t\treturn yield* decodeResponse(output)({\n\t\t\tbody: yield* read(response, variant.value.body),\n\t\t\tcontentType: variant.value.contentType,\n\t\t\tstatus: response.status,\n\t\t\t...variant.value.headers === void 0 ? {} : { headers: Record.fromEntries(headers) }\n\t\t});\n\t}, Effect.mapError(failure));\n\treturn {\n\t\tendpoint,\n\t\texecute,\n\t\tgoogleUpload: Effect.fnUntraced(function* (context, output, request, payload, options) {\n\t\t\tconst client = authorize(yield* HttpClient.HttpClient, context);\n\t\t\tconst media = \"media\" in payload ? yield* mediaBytes(payload.media) : void 0;\n\t\t\tconst size = \"totalBytes\" in payload ? payload.totalBytes : media?.bytes.byteLength ?? 0;\n\t\t\tif (size < 0 || options.maxSize !== void 0 && size > options.maxSize) return yield* refused(\"The upload size is outside the API's declared limit\");\n\t\t\tconst origin = new URL(request.url).origin;\n\t\t\tif (payload.mode === \"start\") {\n\t\t\t\tif (options.resumable === void 0) return yield* refused(\"This API has no resumable upload protocol\");\n\t\t\t\tconst response = yield* client.execute(pipe(HttpClientRequest.setUrl(request, options.resumable), HttpClientRequest.setUrlParam(\"uploadType\", \"resumable\"), HttpClientRequest.setHeaders({\n\t\t\t\t\t\"x-upload-content-length\": `${size}`,\n\t\t\t\t\t\"x-upload-content-type\": payload.contentType\n\t\t\t\t}), HttpClientRequest.bodyJsonUnsafe(payload.metadata ?? {})));\n\t\t\t\tif (response.status < 200 || response.status >= 300) return yield* Effect.fail({\n\t\t\t\t\tcause: yield* response.text,\n\t\t\t\t\tresponse\n\t\t\t\t});\n\t\t\t\tconst sessionUrl = response.headers[\"location\"];\n\t\t\t\tif (sessionUrl === void 0 || !isSafeUrl(sessionUrl, origin)) return yield* Effect.fail({\n\t\t\t\t\tcause: \"The API returned an invalid upload session URL\",\n\t\t\t\t\tresponse\n\t\t\t\t});\n\t\t\t\treturn yield* decodeResponse(output)({\n\t\t\t\t\tnextOffset: 0,\n\t\t\t\t\tsessionUrl,\n\t\t\t\t\tstate: \"pending\"\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (payload.mode === \"chunk\" || payload.mode === \"status\") {\n\t\t\t\tif (!isSafeUrl(payload.sessionUrl, origin)) return yield* refused(\"The upload session URL must use the API's HTTPS origin\");\n\t\t\t\tconst bytes = media?.bytes ?? /* @__PURE__ */ new Uint8Array();\n\t\t\t\tconst end = payload.mode === \"chunk\" ? payload.offset + bytes.byteLength : 0;\n\t\t\t\tif (payload.mode === \"chunk\" && (payload.offset < 0 || bytes.byteLength === 0 || end > size || end < size && bytes.byteLength % 262144 !== 0)) return yield* refused(\"Upload chunks must fit the total size and use 256 KiB multiples except for the final chunk\");\n\t\t\t\tconst response = yield* client.execute(pipe(HttpClientRequest.put(payload.sessionUrl), HttpClientRequest.bodyUint8Array(bytes, media?.contentType ?? \"application/octet-stream\"), HttpClientRequest.setHeader(\"content-range\", payload.mode === \"status\" ? `bytes */${size}` : `bytes ${payload.offset}-${end - 1}/${size}`)));\n\t\t\t\tif (response.status === 308) {\n\t\t\t\t\tconst range = response.headers[\"range\"];\n\t\t\t\t\tif (range !== void 0 && !/^bytes=0-\\d+$/u.test(range)) return yield* Effect.fail({\n\t\t\t\t\t\tcause: \"The API returned an invalid upload range\",\n\t\t\t\t\t\tresponse\n\t\t\t\t\t});\n\t\t\t\t\tconst nextOffset = range === void 0 ? 0 : Number(pipe(range, String.slice(8))) + 1;\n\t\t\t\t\tif (nextOffset > size) return yield* Effect.fail({\n\t\t\t\t\t\tcause: \"The API returned an upload offset beyond the total size\",\n\t\t\t\t\t\tresponse\n\t\t\t\t\t});\n\t\t\t\t\treturn yield* decodeResponse(output)({\n\t\t\t\t\t\tnextOffset,\n\t\t\t\t\t\tsessionUrl: payload.sessionUrl,\n\t\t\t\t\t\tstate: \"pending\"\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tif (response.status < 200 || response.status >= 300) return yield* Effect.fail({\n\t\t\t\t\tcause: yield* response.text,\n\t\t\t\t\tresponse\n\t\t\t\t});\n\t\t\t\treturn yield* decodeResponse(output)({\n\t\t\t\t\tresource: yield* response.json,\n\t\t\t\t\tstate: \"complete\"\n\t\t\t\t});\n\t\t\t}\n\t\t\tconst selected = HttpClientRequest.setUrlParam(request, \"uploadType\", payload.mode);\n\t\t\tconst bytes = media?.bytes ?? /* @__PURE__ */ new Uint8Array();\n\t\t\tconst contentType = media?.contentType ?? \"application/octet-stream\";\n\t\t\tconst boundary = `dual-${yield* Random.nextInt}-${yield* Random.nextInt}`;\n\t\t\tconst metadata = payload.mode === \"multipart\" ? yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))(payload.metadata) : \"\";\n\t\t\tconst body = payload.mode === \"media\" ? HttpClientRequest.bodyUint8Array(selected, bytes, contentType) : HttpClientRequest.bodyUint8Array(selected, new Uint8Array(yield* Effect.promise(() => new Blob([\n\t\t\t\t`--${boundary}\\r\\nContent-Type: application/json; charset=UTF-8\\r\\n\\r\\n${metadata}\\r\\n--${boundary}\\r\\nContent-Type: ${contentType}\\r\\n\\r\\n`,\n\t\t\t\tnew Uint8Array(bytes),\n\t\t\t\t`\\r\\n--${boundary}--\\r\\n`\n\t\t\t]).arrayBuffer())), `multipart/related; boundary=${boundary}`);\n\t\t\tconst response = yield* client.execute(body);\n\t\t\tif (response.status < 200 || response.status >= 300) return yield* Effect.fail({\n\t\t\t\tcause: yield* response.text,\n\t\t\t\tresponse\n\t\t\t});\n\t\t\treturn yield* decodeResponse(output)({\n\t\t\t\tresource: yield* response.json,\n\t\t\t\tstate: \"complete\"\n\t\t\t});\n\t\t}, Effect.mapError(failure)),\n\t\tgraphql: Effect.fnUntraced(function* (context, output, request, field) {\n\t\t\tconst response = yield* send(context, request);\n\t\t\tconst body = yield* Schema.decodeUnknownEffect(GraphqlResponse)(yield* response.json);\n\t\t\tif (body.errors !== void 0 && Array.isReadonlyArrayNonEmpty(body.errors)) return yield* ActionHandlerError.make({\n\t\t\t\tdetails: body.errors,\n\t\t\t\tmessage: Array.join(Array.map(body.errors, (error) => error.message), \"; \")\n\t\t\t});\n\t\t\treturn yield* decodeResponse(output)(body.data?.[field]);\n\t\t}, Effect.mapError(failure)),\n\t\tmcp: Effect.fnUntraced(function* (context, output, server, tool, args, structured) {\n\t\t\tconst connection = yield* connect(authorize(yield* HttpClient.HttpClient, context), server, {});\n\t\t\tconst result = yield* Schema.decodeUnknownEffect(CallToolResult)(yield* connection.request(\"tools/call\", {\n\t\t\t\targuments: args,\n\t\t\t\tname: tool\n\t\t\t}));\n\t\t\tif (result.isError === true) return yield* ActionHandlerError.make({\n\t\t\t\tdetails: result.content,\n\t\t\t\tmessage: Array.join(Array.flatMap(result.content, (block) => Array.fromNullishOr(block.text)), \"\\n\")\n\t\t\t});\n\t\t\treturn yield* decodeResponse(output)(Boolean.match(structured, {\n\t\t\t\tonFalse: () => ({ content: result.content }),\n\t\t\t\tonTrue: () => result.structuredContent\n\t\t\t}));\n\t\t}, Effect.scoped, Effect.mapError((error) => Schema.is(McpError)(error) ? ActionHandlerError.make({ message: error.message }) : failure(error))),\n\t\tvariants\n\t};\n}\nexport { Base64FromFile, Base64UrlFromFile, DataUriFromFile, DateTimeFromRfc2822, DateTimeFromUnixSeconds, File, FileFromBase64, FileFromBase64Url, FileFromDataUri, Http_exports as Http, Http_exports, Rfc2822FromDateTime, UnixSecondsFromDateTime, continuation, decoded, form, literal, make, params, path, preauthenticated, segments, withFile, withForm };\n\n//# sourceMappingURL=Http.js.map",
+    "import { __exportAll } from \"./_virtual/_rolldown/runtime.js\";\nimport \"./auth.js\";\nimport { Boolean, Match, Schema, String, flow, pipe } from \"effect\";\nimport { HttpClient, HttpClientRequest } from \"effect/http\";\nimport { AuthMethod } from \"@dual-os/sdk\";\n//#region src/auth.ts\nvar auth_exports = /* @__PURE__ */ __exportAll({\n\tAuth: () => auth_exports,\n\tauthMethods: () => authMethods,\n\tauthorize: () => authorize\n});\nconst authMethods = [\n\tAuthMethod.make(\"cloud\", {\n\t\tdescription: \"Authenticate with Jira and Confluence Cloud using an email and API token\",\n\t\tname: \"Atlassian Cloud API\",\n\t\tschema: Schema.Struct({\n\t\t\tapiToken: Schema.String,\n\t\t\tdomain: Schema.String,\n\t\t\temail: Schema.String\n\t\t})\n\t}),\n\tAuthMethod.make(\"server\", {\n\t\tdescription: \"Authenticate with a self-hosted Jira Server using an email and password. Routes Jira only: Confluence Data Center serves a different API.\",\n\t\tname: \"Jira Server API\",\n\t\tschema: Schema.Struct({\n\t\t\tdomain: Schema.String,\n\t\t\temail: Schema.String,\n\t\t\tpassword: Schema.String\n\t\t})\n\t}),\n\tAuthMethod.make(\"server-pat\", {\n\t\tdescription: \"Authenticate with a self-hosted Jira Server using a personal access token. Routes Jira only: Confluence Data Center serves a different API.\",\n\t\tname: \"Jira Server PAT API\",\n\t\tschema: Schema.Struct({\n\t\t\tdomain: Schema.String,\n\t\t\tpersonalAccessToken: Schema.String\n\t\t})\n\t}),\n\tAuthMethod.oauth2(\"oauth\", {\n\t\tauthorizationParams: {\n\t\t\taudience: \"api.atlassian.com\",\n\t\t\tprompt: \"consent\"\n\t\t},\n\t\tauthorizationUrl: \"https://auth.atlassian.com/authorize\",\n\t\tclient: (options) => ({\n\t\t\tauthentication: \"post\",\n\t\t\tclientId: options.setup.clientId,\n\t\t\tclientSecret: options.setup.clientSecret\n\t\t}),\n\t\tdescription: \"Authenticate with Jira and Confluence Cloud via Atlassian OAuth2 (3LO)\",\n\t\tmaterial: AuthMethod.OAuth2TokenMaterial,\n\t\tname: \"Atlassian OAuth2\",\n\t\tresolve: (material, context) => ({\n\t\t\taccessToken: material.accessToken,\n\t\t\tcloudId: context.setup.cloudId\n\t\t}),\n\t\tscopes: [\n\t\t\t\"read:jira-work\",\n\t\t\t\"write:jira-work\",\n\t\t\t\"read:jira-user\",\n\t\t\t\"manage:jira-project\",\n\t\t\t\"manage:jira-configuration\",\n\t\t\t\"manage:jira-webhook\",\n\t\t\t\"read:page:confluence\",\n\t\t\t\"write:page:confluence\",\n\t\t\t\"delete:page:confluence\",\n\t\t\t\"read:space:confluence\",\n\t\t\t\"read:comment:confluence\",\n\t\t\t\"write:comment:confluence\",\n\t\t\t\"delete:comment:confluence\",\n\t\t\t\"read:attachment:confluence\",\n\t\t\t\"write:attachment:confluence\",\n\t\t\t\"delete:attachment:confluence\",\n\t\t\t\"read:label:confluence\",\n\t\t\t\"read:folder:confluence\",\n\t\t\t\"write:folder:confluence\",\n\t\t\t\"read:hierarchical-content:confluence\",\n\t\t\t\"read:content.metadata:confluence\",\n\t\t\t\"read:user:confluence\",\n\t\t\t\"read:content-details:confluence\",\n\t\t\t\"readonly:content.attachment:confluence\",\n\t\t\t\"read:confluence-content.all\",\n\t\t\t\"write:confluence-content\",\n\t\t\t\"read:confluence-user\",\n\t\t\t\"write:confluence-file\",\n\t\t\t\"search:confluence\",\n\t\t\t\"offline_access\"\n\t\t],\n\t\tsetup: Schema.Struct({\n\t\t\tclientId: Schema.String,\n\t\t\tclientSecret: Schema.String,\n\t\t\tcloudId: Schema.String\n\t\t}),\n\t\ttokenUrl: \"https://auth.atlassian.com/oauth/token\",\n\t\tvalue: Schema.Struct({\n\t\t\taccessToken: Schema.String,\n\t\t\tcloudId: Schema.String\n\t\t})\n\t})\n];\nfunction withDomain(domain) {\n\treturn HttpClientRequest.updateUrl(String.replace(/^https?:\\/\\/[^/]+/u, String.replace(/\\/+$/u, \"\")(domain)));\n}\nconst toServerApi = HttpClientRequest.updateUrl(String.replace(\"/rest/api/3/\", \"/rest/api/2/\"));\nfunction authorize(client, context) {\n\treturn pipe(Match.value(context.auth.current), Match.discriminatorsExhaustive(\"methodId\")({\n\t\tcloud: (binding) => HttpClient.mapRequest(client, flow(HttpClientRequest.basicAuth(binding.value.email, binding.value.apiToken), withDomain(binding.value.domain))),\n\t\toauth: (binding) => HttpClient.mapRequest(client, flow(HttpClientRequest.bearerToken(binding.value.accessToken), HttpClientRequest.updateUrl((url) => {\n\t\t\tconst path = String.replace(/^https?:\\/\\/[^/]+/u, \"\")(url);\n\t\t\treturn `https://api.atlassian.com/ex/${Boolean.match(String.startsWith(\"/wiki/\")(path), {\n\t\t\t\tonFalse: () => \"jira\",\n\t\t\t\tonTrue: () => \"confluence\"\n\t\t\t})}/${binding.value.cloudId}${path}`;\n\t\t}))),\n\t\tserver: (binding) => HttpClient.mapRequest(client, flow(HttpClientRequest.basicAuth(binding.value.email, binding.value.password), withDomain(binding.value.domain), toServerApi)),\n\t\t\"server-pat\": (binding) => HttpClient.mapRequest(client, flow(HttpClientRequest.bearerToken(binding.value.personalAccessToken), withDomain(binding.value.domain), toServerApi))\n\t}), HttpClient.mapRequest(HttpClientRequest.setHeader(\"X-Atlassian-Token\", \"no-check\")));\n}\n//#endregion\nexport { auth_exports as Auth, authMethods, auth_exports, authorize };\n\n//# sourceMappingURL=auth.js.map"
+  ],
+  "mappings": "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",
+  "debugId": "10970BDA1293765564756E2164756E21",
+  "names": []
+}