@dual-os/notion-api 0.0.0-stage → 6.0.4

package/plugin-529jjg5q.js

@@ -0,0 +1,1303 @@
+// @bun
+import {
+  __exportAll2
+} from "./plugin-2jdfj02n.js";
+import {
+  dual,
+  identity,
+  pipe,
+  flow,
+  isString,
+  isObject,
+  hasProperty,
+  equals,
+  PipeInspectableProto,
+  Number2,
+  mapInput,
+  none,
+  some,
+  isNone,
+  match2,
+  getOrElse,
+  orElse,
+  fromNullishOr,
+  fromUndefinedOr,
+  getOrNull,
+  getOrUndefined,
+  liftThrowable,
+  map,
+  flatMap,
+  filter,
+  liftPredicate,
+  Reference,
+  succeed,
+  fail,
+  failVoid,
+  fromOption,
+  try_,
+  isSuccess,
+  match3,
+  fromEntries,
+  toEntries,
+  has,
+  map2,
+  ensure,
+  append,
+  isArray,
+  isReadonlyArrayNonEmpty,
+  getUnsafe2,
+  headNonEmpty,
+  findFirst,
+  sort,
+  zip,
+  contains2,
+  empty,
+  map3,
+  flatMap2,
+  filterMap,
+  filter2,
+  reduce,
+  fromNullishOr2,
+  every,
+  join,
+  millis,
+  TaggedClass,
+  TaggedError,
+  increment,
+  toLowerCase,
+  replace,
+  trim,
+  slice,
+  isEmpty,
+  isNonEmpty,
+  split,
+  startsWith,
+  endsWith,
+  match4,
+  replaceAll,
+  isEffect,
+  forEach,
+  promise,
+  succeed4,
+  suspend,
+  sync,
+  void_2,
+  gen,
+  fail5,
+  withFiber,
+  fromOption2,
+  flatMap3,
+  result,
+  map4,
+  mapError,
+  orDie,
+  ignore,
+  serviceOption,
+  provideService,
+  scoped,
+  acquireRelease,
+  fnUntraced,
+  fn,
+  encode,
+  encode2,
+  decode,
+  makeZoned,
+  make3,
+  toUtc,
+  toDateUtc,
+  toEpochMillis,
+  formatIso,
+  formatIsoOffset,
+  empty2,
+  empty3,
+  InvalidValue,
+  compose,
+  transform,
+  transformEffect,
+  is,
+  decodeUnknownEffect,
+  decodeOption,
+  encodeEffect,
+  isSchema,
+  optionalKey,
+  optional,
+  toType,
+  Literal,
+  Unknown,
+  String3,
+  Boolean2,
+  Struct,
+  Record,
+  StructWithRest,
+  ArraySchema,
+  Literals,
+  NullOr,
+  decodeTo,
+  Int,
+  Natural,
+  NonEmptyString,
+  Defect,
+  fromJsonString,
+  Uint8ArrayFromBase64,
+  TaggedError2,
+  toEquivalence,
+  Json,
+  make5,
+  get2,
+  set,
+  update,
+  fromEffect,
+  fromIterable3,
+  paginate,
+  unwrap2,
+  mapEffect,
+  flatMap4,
+  filterMap2,
+  decodeText,
+  runCollect,
+  runHead,
+  value2,
+  discriminatorsExhaustive,
+  empty5,
+  HttpClientError,
+  InvalidUrlError,
+  makeWith,
+  post,
+  put,
+  del,
+  setMethod,
+  setHeader,
+  setHeaders,
+  bearerToken,
+  setUrl,
+  setUrlParam,
+  setBody,
+  bodyUint8Array,
+  bodyJsonUnsafe,
+  bodyFormDataRecord,
+  HttpClient,
+  transformResponse,
+  filterStatusOk,
+  mapRequest,
+  mapRequestEffect,
+  RequestInit,
+  __exportAll3,
+  ActionHandlerError,
+  fromHttpClientFailure,
+  AuthMethod_exports,
+  Schema,
+  Key,
+  Event,
+  commandSchema,
+  Service2,
+  File3,
+  read,
+  write
+} from "./plugin-1s0prvga.js";
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/random.js
+var Random = /* @__PURE__ */ Reference("effect/Random", {
+  defaultValue: () => ({
+    nextIntUnsafe() {
+      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;
+    },
+    nextDoubleUnsafe() {
+      return Math.random();
+    }
+  })
+});
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Random.js
+var Random2 = Random;
+var randomWith = (f) => withFiber((fiber) => succeed4(f(fiber.getRef(Random2))));
+var nextInt = /* @__PURE__ */ randomWith((r) => r.nextIntUnsafe());
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Boolean.js
+var Boolean = globalThis.Boolean;
+var match = /* @__PURE__ */ dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Ref.js
+var TypeId = "~effect/Ref";
+var RefProto = {
+  [TypeId]: {
+    _A: identity
+  },
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "Ref",
+      ref: this.ref
+    };
+  }
+};
+var makeUnsafe = (value) => {
+  const self = Object.create(RefProto);
+  self.ref = make5(value);
+  return self;
+};
+var make = (value) => sync(() => makeUnsafe(value));
+var get = (self) => sync(() => self.ref.current);
+var set2 = /* @__PURE__ */ dual(2, (self, value) => sync(() => set(self.ref, value)));
+var getAndUpdate = /* @__PURE__ */ dual(2, (self, f) => sync(() => {
+  const current = self.ref.current;
+  self.ref.current = f(current);
+  return current;
+}));
+
+// ../../../../node_modules/.bun/effect@4.1.2/node_modules/effect/dist/encoding/Sse.js
+var SseErrorTypeId = "~effect/encoding/Sse/SseError";
+
+class EventTooLarge extends (/* @__PURE__ */ TaggedError("EventTooLarge")) {
+  get message() {
+    return `Pending SSE event exceeded the maximum size of ${this.maxEventSize}`;
+  }
+}
+
+class SseError extends (/* @__PURE__ */ TaggedError("SseError")) {
+  [SseErrorTypeId] = SseErrorTypeId;
+  get message() {
+    return this.reason.message;
+  }
+}
+var defaultMaxEventSize = 10 * 1024 * 1024;
+function makeParser(onParse, options) {
+  const maxEventSize = options?.maxEventSize ?? defaultMaxEventSize;
+  const dispatchEmptyNamedEvents = options?.dispatchEmptyNamedEvents === true;
+  let isFirstChunk;
+  let pending;
+  let pendingLength;
+  let discardTrailingNewline;
+  let generation = 0;
+  let lastEventId;
+  let eventName;
+  let data;
+  reset();
+  return {
+    feed,
+    reset
+  };
+  function reset() {
+    generation++;
+    isFirstChunk = true;
+    pending = [];
+    pendingLength = 0;
+    discardTrailingNewline = false;
+    lastEventId = undefined;
+    eventName = undefined;
+    data = "";
+  }
+  function feed(chunk) {
+    if (chunk.length === 0)
+      return;
+    if (isFirstChunk && chunk.startsWith(BOM)) {
+      chunk = chunk.slice(BOM.length);
+    }
+    isFirstChunk = false;
+    const length = chunk.length;
+    const currentGeneration = generation;
+    let position = 0;
+    while (position < length) {
+      if (discardTrailingNewline) {
+        discardTrailingNewline = false;
+        if (chunk.charCodeAt(position) === LF) {
+          ++position;
+          continue;
+        }
+      }
+      let lineEnd = position;
+      while (lineEnd < length) {
+        const code = chunk.charCodeAt(lineEnd);
+        if (code === CR || code === LF)
+          break;
+        ++lineEnd;
+      }
+      if (lineEnd === length) {
+        pending.push(chunk.slice(position));
+        pendingLength += length - position;
+        break;
+      }
+      discardTrailingNewline = chunk.charCodeAt(lineEnd) === CR;
+      let line = chunk.slice(position, lineEnd);
+      if (pending.length > 0) {
+        pending.push(line);
+        line = pending.join("");
+        pending = [];
+        pendingLength = 0;
+      }
+      parseLine(line);
+      if (generation !== currentGeneration) {
+        return;
+      }
+      position = lineEnd + 1;
+    }
+    if (pendingLength + data.length > maxEventSize) {
+      const error = new SseError({
+        reason: new EventTooLarge({
+          maxEventSize
+        })
+      });
+      reset();
+      return error;
+    }
+  }
+  function parseLine(line) {
+    if (line.length === 0) {
+      const named = eventName !== undefined && eventName !== "";
+      const event = eventName || "message";
+      const eventData = data;
+      eventName = undefined;
+      data = "";
+      if (eventData.length > 0 || dispatchEmptyNamedEvents && named) {
+        onParse({
+          _tag: "Event",
+          id: lastEventId,
+          event,
+          data: eventData.slice(0, -1)
+        });
+      }
+      return;
+    }
+    const colon = line.indexOf(":");
+    let field = line;
+    let value = "";
+    if (colon >= 0) {
+      field = line.slice(0, colon);
+      value = line.slice(line.charCodeAt(colon + 1) === SPACE ? colon + 2 : colon + 1);
+    }
+    if (field === "data") {
+      data += value + `
+`;
+    } else if (field === "event") {
+      eventName = value;
+    } else if (field === "id" && !value.includes("\x00")) {
+      lastEventId = value;
+    } else if (field === "retry" && /^\d+$/.test(value)) {
+      const retry = parseInt(value, 10);
+      onParse(new Retry({
+        duration: millis(retry),
+        lastEventId
+      }));
+    }
+  }
+}
+var BOM = "\uFEFF";
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var RetryTypeId = "~effect/encoding/Sse/Retry";
+
+class Retry extends (/* @__PURE__ */ TaggedClass("Retry")) {
+  [RetryTypeId] = RetryTypeId;
+  static is(u) {
+    return hasProperty(u, RetryTypeId);
+  }
+  static filter(u) {
+    return Retry.is(u) ? succeed(u) : fail(u);
+  }
+}
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/AgentChannelConformance.js
+var Command = commandSchema(Json);
+var Fixture = Struct({
+  activate: Command,
+  channelId: Key,
+  connectionId: optionalKey(Key),
+  deactivate: Command,
+  definitionSettings: Json,
+  deliver: Command,
+  deploymentSettings: Json,
+  receive: Command
+});
+var ConformanceError = class extends TaggedError2()("AgentChannelConformanceError", {
+  command: Literals([
+    "activate",
+    "deactivate",
+    "receive",
+    "deliver"
+  ]),
+  rule: Literals([
+    "command_kind",
+    "stable_result",
+    "stable_events",
+    "boundary_rejection"
+  ])
+}) {
+};
+var run = fn("AgentChannelConformance.run")(function* (input) {
+  const fixture = yield* decodeUnknownEffect(Fixture)(input, { onExcessProperty: "error" });
+  const runtime = yield* Service2;
+  const definition = yield* runtime.getAgentChannel({ channelId: fixture.channelId });
+  const { activate, receive, deliver, deactivate, ...config } = fixture;
+  const { connectionId: _connectionId, ...withoutConnection } = config;
+  const probes = [
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        channelId: "",
+        command: activate
+      }
+    },
+    {
+      input: {
+        ...config,
+        channelId: "conformance/missing/channel",
+        command: activate
+      },
+      code: "not_found"
+    },
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        command: {
+          ...activate,
+          operationKey: ""
+        }
+      }
+    },
+    {
+      code: "invalid_input",
+      input: {
+        ...config,
+        agent: { id: "synthetic-authority" },
+        command: activate
+      }
+    },
+    {
+      code: "invalid_auth",
+      input: definition.authMethods.length === 0 ? {
+        ...config,
+        command: activate,
+        connectionId: "unexpected"
+      } : {
+        ...withoutConnection,
+        command: activate
+      }
+    }
+  ];
+  for (const probe of probes) {
+    const outcome = yield* suspend(() => runtime.executeAgentChannel(probe.input)).pipe(result);
+    if (outcome._tag !== "Failure" || outcome.failure.code !== probe.code)
+      return yield* new ConformanceError({
+        command: "activate",
+        rule: "boundary_rejection"
+      });
+  }
+  const commands = [
+    ["activate", activate],
+    ["receive", receive],
+    ["deliver", deliver],
+    ["deactivate", deactivate]
+  ];
+  for (const [kind, command] of commands)
+    if (command.kind !== kind)
+      return yield* new ConformanceError({
+        command: kind,
+        rule: "command_kind"
+      });
+  const activated = yield* acquireRelease(runtime.executeAgentChannel({
+    ...config,
+    command: activate
+  }), (result2) => runtime.executeAgentChannel({
+    ...config,
+    command: {
+      ...deactivate,
+      ...result2.kind === "activate" ? {
+        installationKey: result2.installationKey,
+        state: result2.state
+      } : {}
+    }
+  }).pipe(orDie));
+  for (const [kind, command] of commands) {
+    const first = kind === "activate" ? activated : yield* runtime.executeAgentChannel({
+      ...config,
+      command
+    });
+    if (kind === "deliver" && definition.features.deliveryMode === "at-most-once")
+      continue;
+    const second = yield* runtime.executeAgentChannel({
+      ...config,
+      command
+    });
+    const firstJson = yield* decodeUnknownEffect(Json)(first);
+    const secondJson = yield* decodeUnknownEffect(Json)(second);
+    if (!toEquivalence(Json)(firstJson, secondJson))
+      return yield* new ConformanceError({
+        command: kind,
+        rule: "stable_result"
+      });
+    if (kind === "receive") {
+      const nextReceipt = yield* runtime.executeAgentChannel({
+        ...config,
+        command: {
+          ...command,
+          operationKey: `${command.operationKey.slice(0, 500)}:replay`
+        }
+      });
+      if (first.kind !== "receive" || nextReceipt.kind !== "receive" || !toEquivalence(ArraySchema(Event))(first.events, nextReceipt.events))
+        return yield* new ConformanceError({
+          command: kind,
+          rule: "stable_events"
+        });
+    }
+  }
+}, scoped);
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/Mcp.js
+var McpError = class extends TaggedError2()("McpError", {
+  cause: optional(Defect()),
+  message: String3
+}) {
+};
+var protocolVersion = "2025-06-18";
+var Implementation = Struct({
+  name: String3,
+  title: optionalKey(String3),
+  version: String3
+});
+var Tool = Struct({
+  annotations: optionalKey(Struct({ title: optionalKey(String3) })),
+  description: optionalKey(String3),
+  inputSchema: Record(String3, Unknown),
+  name: String3,
+  outputSchema: optionalKey(Record(String3, Unknown)),
+  title: optionalKey(String3)
+});
+var ListToolsResult = Struct({
+  nextCursor: optionalKey(String3),
+  tools: ArraySchema(Tool)
+});
+var ContentBlock = StructWithRest(Struct({
+  text: optionalKey(String3),
+  type: String3
+}), [Record(String3, Unknown)]);
+var CallToolResult = Struct({
+  content: ArraySchema(ContentBlock),
+  isError: optionalKey(Boolean2),
+  structuredContent: optionalKey(Unknown)
+});
+var InitializeResult = Struct({
+  protocolVersion: String3,
+  serverInfo: Implementation
+});
+var Message = Struct({
+  error: optionalKey(Struct({ message: String3 })),
+  id: optionalKey(Unknown),
+  result: optionalKey(Unknown)
+});
+var responseTo = fnUntraced(function* (id, method, response) {
+  const payloads = match(pipe(response.headers["content-type"] ?? "", startsWith("text/event-stream")), {
+    onFalse: () => fromEffect(response.text),
+    onTrue: () => unwrap2(sync(() => {
+      const events = make5(empty());
+      const parser = makeParser((event) => {
+        if (event._tag === "Event")
+          update(events, append(event.data));
+      });
+      return pipe(response.stream, decodeText(), mapEffect((chunk) => {
+        const error = parser.feed(chunk);
+        if (error !== undefined)
+          return fail5(McpError.make({
+            cause: error,
+            message: error.message
+          }));
+        const ready = get2(events);
+        set(events, empty());
+        return succeed4(ready);
+      }), flatMap4(fromIterable3));
+    }))
+  });
+  const found = yield* pipe(payloads, filterMap2((payload) => fromOption(filter(decodeOption(fromJsonString(Message))(payload), (message) => message.id === id && (message.result !== undefined || message.error !== undefined)), () => payload)), runHead);
+  return yield* fromOption2(found, () => McpError.make({ message: `${method} got no response` }));
+});
+var connect = fn("Mcp.connect")(function* (client, endpoint, headers) {
+  const checked = filterStatusOk(client);
+  const post2 = fnUntraced(function* (version, session, body) {
+    return yield* checked.execute(pipe(post(endpoint), setHeaders({
+      ...headers,
+      accept: "application/json, text/event-stream",
+      "mcp-protocol-version": version,
+      ...match2(session, {
+        onNone: () => ({}),
+        onSome: (id) => ({ "mcp-session-id": id })
+      })
+    }), bodyJsonUnsafe({
+      jsonrpc: "2.0",
+      ...body
+    })));
+  });
+  const call = fnUntraced(function* (version, session, id, method, params) {
+    const response = yield* post2(version, session, {
+      id,
+      method,
+      params
+    });
+    const message = yield* responseTo(id, method, response);
+    if (message.error !== undefined)
+      return yield* McpError.make({ message: `${method}: ${message.error.message}` });
+    return {
+      result: message.result,
+      session: orElse(fromNullishOr(response.headers["mcp-session-id"]), () => session)
+    };
+  });
+  const negotiatedVersion = yield* make(protocolVersion);
+  const initialized = yield* acquireRelease(call(protocolVersion, none(), 0, "initialize", {
+    capabilities: {},
+    clientInfo: {
+      name: "dual",
+      version: "1"
+    },
+    protocolVersion
+  }), (opened) => match2(opened.session, {
+    onNone: () => void_2,
+    onSome: (id) => flatMap3(get(negotiatedVersion), (version) => ignore(client.execute(pipe(del(endpoint), setHeaders({
+      ...headers,
+      "mcp-protocol-version": version,
+      "mcp-session-id": id
+    })))))
+  }));
+  const server = yield* decodeUnknownEffect(InitializeResult)(initialized.result);
+  if (server.protocolVersion !== protocolVersion && server.protocolVersion !== "2025-03-26")
+    return yield* McpError.make({ message: `Unsupported MCP protocol version ${server.protocolVersion}` });
+  yield* set2(negotiatedVersion, server.protocolVersion);
+  yield* post2(server.protocolVersion, initialized.session, { method: "notifications/initialized" });
+  const ids = yield* make(1);
+  return {
+    request: fn("Mcp.request")(function* (method, params) {
+      return (yield* call(server.protocolVersion, initialized.session, yield* getAndUpdate(ids, increment), method, params)).result;
+    }),
+    server: server.serverInfo
+  };
+});
+var listTools = fn("Mcp.listTools")(function* (client, endpoint, headers) {
+  const session = yield* connect(client, endpoint, headers);
+  const tools = yield* runCollect(paginate({}, fnUntraced(function* (params) {
+    const page = yield* decodeUnknownEffect(ListToolsResult)(yield* session.request("tools/list", params));
+    return [page.tools, map(fromUndefinedOr(page.nextCursor), (cursor) => ({ cursor }))];
+  })));
+  return {
+    server: session.server,
+    tools
+  };
+}, scoped);
+
+// ../../../../node_modules/.bun/@dual-os+sdk@0.9.0+a827849ded09603e/node_modules/@dual-os/sdk/dist/Http.js
+var Http_exports = /* @__PURE__ */ __exportAll3({
+  Base64FromFile: () => Base64FromFile2,
+  Base64UrlFromFile: () => Base64UrlFromFile2,
+  DataUriFromFile: () => DataUriFromFile2,
+  DateTimeFromRfc2822: () => DateTimeFromRfc28222,
+  DateTimeFromUnixSeconds: () => DateTimeFromUnixSeconds2,
+  File: () => File2,
+  FileFromBase64: () => FileFromBase642,
+  FileFromBase64Url: () => FileFromBase64Url2,
+  FileFromDataUri: () => FileFromDataUri2,
+  Http: () => Http_exports,
+  Rfc2822FromDateTime: () => Rfc2822FromDateTime2,
+  UnixSecondsFromDateTime: () => UnixSecondsFromDateTime2,
+  continuation: () => continuation2,
+  decoded: () => decoded2,
+  form: () => form2,
+  literal: () => literal2,
+  make: () => make2,
+  params: () => params2,
+  path: () => path2,
+  preauthenticated: () => preauthenticated2,
+  segments: () => segments2,
+  withFile: () => withFile,
+  withForm: () => withForm
+});
+function preserveJsonProperties(value, input) {
+  if (equals(value, input))
+    return value;
+  if (isArray(value) && isArray(input))
+    for (const entry of zip(value, input))
+      preserveJsonProperties(entry[0], entry[1]);
+  else if (isObject(value) && isObject(input))
+    for (const entry of toEntries(input))
+      if (has(value, entry[0]))
+        preserveJsonProperties(value[entry[0]], entry[1]);
+      else
+        Object.defineProperty(value, entry[0], {
+          configurable: true,
+          enumerable: true,
+          value: entry[1],
+          writable: true
+        });
+  return value;
+}
+function decodeResponse(output) {
+  return flow(succeed4, flatMap3((input) => pipe(decodeUnknownEffect(output)(input), map4((value) => preserveJsonProperties(value, input)))));
+}
+var File2 = Struct({
+  _tag: optionalKey(Literal("ToolFile")),
+  contentBase64: Uint8ArrayFromBase64,
+  contentType: optionalKey(NullOr(String3)),
+  filename: optionalKey(NullOr(String3)),
+  sizeBytes: optionalKey(Natural)
+}).annotate({ description: "A ToolFile, such as the result of a download, passed unchanged; or its contentBase64 with an optional contentType and filename." });
+var signatures = [
+  ["image/jpeg", [[0, [
+    255,
+    216,
+    255
+  ]]]],
+  ["image/png", [[0, [
+    137,
+    80,
+    78,
+    71
+  ]]]],
+  ["image/gif", [[0, [
+    71,
+    73,
+    70,
+    56
+  ]]]],
+  ["image/webp", [[0, [
+    82,
+    73,
+    70,
+    70
+  ]], [8, [
+    87,
+    69,
+    66,
+    80
+  ]]]],
+  ["application/pdf", [[0, [
+    37,
+    80,
+    68,
+    70
+  ]]]],
+  ["application/zip", [[0, [
+    80,
+    75,
+    3,
+    4
+  ]]]]
+];
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function sniff(bytes) {
+  return pipe(findFirst(signatures, (signature) => every(signature[1], (part) => every(part[1], (byte, index) => bytes[part[0] + index] === byte))), map((signature) => signature[0]), orElse(() => liftPredicate("text/plain", () => isSuccess(try_(() => utf8.decode(bytes))))), getOrNull);
+}
+function toolFile(bytes, declared, filename) {
+  return {
+    _tag: "ToolFile",
+    contentBase64: encode(bytes),
+    contentType: declared === null || pipe(declared, startsWith("application/octet-stream")) ? sniff(bytes) ?? declared : declared,
+    filename,
+    sizeBytes: bytes.byteLength
+  };
+}
+function invalid(expected, value, options) {
+  return fail5(new InvalidValue({ expected }, value, options));
+}
+function decodeBytes(text, options) {
+  return match3(decode(pipe(text, replaceAll("+", "-"), replaceAll("/", "_"))), {
+    onFailure: () => invalid("a Base64 or Base64Url string", text, options),
+    onSuccess: (bytes) => succeed4(bytes)
+  });
+}
+function contentOf(carrier) {
+  return transformEffect((text, options) => {
+    if (carrier !== "data-uri")
+      return map4(decodeBytes(text, options), (bytes) => ({
+        bytes,
+        contentType: null
+      }));
+    return match2(pipe(text, match4(/^data:([^;,]*)(?:;[^;,]*)*;base64,(.*)$/su)), {
+      onNone: () => invalid("a Base64 data URI", text, options),
+      onSome: (parts) => map4(decodeBytes(getUnsafe2(parts, 2), options), (bytes) => ({
+        bytes,
+        contentType: pipe(getUnsafe2(parts, 1), liftPredicate(isNonEmpty), getOrNull)
+      }))
+    });
+  });
+}
+function textOf(carrier, content) {
+  if (carrier === "base64")
+    return encode(content.bytes);
+  if (carrier === "base64url")
+    return encode2(content.bytes);
+  return `data:${content.contentType ?? sniff(content.bytes) ?? "application/octet-stream"};base64,${encode(content.bytes)}`;
+}
+function fileFrom(carrier) {
+  return String3.pipe(decodeTo(Schema, {
+    decode: compose(contentOf(carrier), transform((content) => toolFile(content.bytes, content.contentType, null))),
+    encode: transformEffect((file, options) => map4(decodeBytes(file.contentBase64, options), (bytes) => textOf(carrier, {
+      bytes,
+      contentType: file.contentType
+    })))
+  }));
+}
+function encodedFrom(carrier) {
+  return File2.pipe(decodeTo(String3, {
+    decode: transform((file) => textOf(carrier, {
+      bytes: file.contentBase64,
+      contentType: file.contentType ?? null
+    })),
+    encode: compose(contentOf(carrier), transform((content) => ({
+      contentBase64: content.bytes,
+      contentType: content.contentType
+    })))
+  }));
+}
+var FileFromBase642 = fileFrom("base64");
+var FileFromBase64Url2 = fileFrom("base64url");
+var Base64FromFile2 = encodedFrom("base64");
+var Base64UrlFromFile2 = encodedFrom("base64url");
+var FileFromDataUri2 = fileFrom("data-uri");
+var DataUriFromFile2 = encodedFrom("data-uri");
+var DateTimeText = String3.annotate({ format: "date-time" });
+var rfc3339 = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.\d+)?(?:Z|([+-]\d{2}:\d{2}))$/u;
+function rfc3339Instant(text) {
+  return pipe(fromNullishOr(rfc3339.exec(text)), flatMap((match5) => filter(makeZoned(text, { timeZone: match5[2] ?? "+00:00" }), (zoned) => startsWith(match5[1] ?? "")(formatIsoOffset(zoned)))), map(toUtc));
+}
+function instants(wire, expected, read, write) {
+  const fromWire = transformEffect((value, options) => match2(read(value), {
+    onNone: () => invalid(expected, value, options),
+    onSome: (instant) => succeed4(formatIso(instant))
+  }));
+  const toWire = transformEffect((text, options) => match2(rfc3339Instant(text), {
+    onNone: () => invalid("an ISO 8601 date-time", text, options),
+    onSome: (instant) => succeed4(write(instant))
+  }));
+  return {
+    input: pipe(DateTimeText, decodeTo(wire, {
+      decode: toWire,
+      encode: fromWire
+    })),
+    output: pipe(wire, decodeTo(DateTimeText, {
+      decode: fromWire,
+      encode: toWire
+    }))
+  };
+}
+var unixSeconds = instants(Int, "Unix seconds", (seconds) => map(make3(seconds * 1000), toUtc), (instant) => Math.floor(toEpochMillis(instant) / 1000));
+var rfc2822 = instants(String3, "an RFC 2822 date-time", (text) => map(make3(text), toUtc), (instant) => toDateUtc(instant).toUTCString());
+var DateTimeFromUnixSeconds2 = unixSeconds.output;
+var UnixSecondsFromDateTime2 = unixSeconds.input;
+var DateTimeFromRfc28222 = rfc2822.output;
+var Rfc2822FromDateTime2 = rfc2822.input;
+function decoded2(wire) {
+  return {
+    _tag: "Decoded",
+    wire
+  };
+}
+var GraphqlResponse = Struct({
+  data: optionalKey(NullOr(Record(String3, Unknown))),
+  errors: optionalKey(ArraySchema(StructWithRest(Struct({ message: String3 }), [Record(String3, Unknown)])))
+});
+function coerce(value) {
+  return isObject(value) ? JSON.stringify(value) : `${value}`;
+}
+function path2(value) {
+  return encodeURIComponent(coerce(value));
+}
+function literal2(value) {
+  return path2(pipe(coerce(value), replaceAll("'", "''")));
+}
+function segments2(value) {
+  return join(map3(split(coerce(value), "/"), encodeURIComponent), "/");
+}
+function deepObject(name, value) {
+  if (isArray(value))
+    return flatMap2(value, (item, index) => deepObject(`${name}[${index}]`, item));
+  if (isObject(value))
+    return flatMap2(toEntries(value), (entry) => deepObject(`${name}[${entry[0]}]`, entry[1]));
+  return value === undefined ? [] : [[name, coerce(value)]];
+}
+function params2(fields, joined = [], deep = [], exploded = []) {
+  return flatMap2(toEntries(fields), (field) => {
+    if (field[1] === undefined)
+      return [];
+    if (contains2(deep, field[0]))
+      return deepObject(field[0], field[1]);
+    const values = field[1];
+    if (contains2(exploded, field[0]) && isObject(values) && !isArray(values))
+      return filterMap(toEntries(values), (entry) => entry[1] === undefined ? failVoid : succeed([entry[0], coerce(entry[1])]));
+    if (!isArray(values))
+      return [[field[0], coerce(values)]];
+    const separator = findFirst(joined, (entry) => {
+      const pair = isString(entry) ? [entry, ","] : entry;
+      return pair[0] === field[0] ? some(pair[1]) : none();
+    });
+    return match2(separator, {
+      onNone: () => map3(values, (item) => [field[0], coerce(item)]),
+      onSome: (value) => [[field[0], join(map3(values, coerce), value)]]
+    });
+  });
+}
+function filePart(bytes, name, contentType) {
+  return new globalThis.File([new Uint8Array(bytes)], name, { type: contentType });
+}
+function form2(payload) {
+  return map2(payload, (value, name) => map3(ensure(value), (item) => {
+    if (item === undefined)
+      return;
+    if (!is(File2)(item))
+      return coerce(item);
+    return filePart(item.contentBase64, item.filename ?? name, item.contentType ?? "application/octet-stream");
+  }));
+}
+function fileFailed(error) {
+  return ActionHandlerError.make({
+    cause: error,
+    message: error.message
+  });
+}
+function readFile(file) {
+  return pipe(read(file), mapError(fileFailed));
+}
+var withFile = fnUntraced(function* (request, file) {
+  return bodyUint8Array(request, yield* readFile(file), file.contentType);
+});
+var withForm = fnUntraced(function* (request, payload) {
+  return bodyFormDataRecord(request, fromEntries(yield* forEach(toEntries(payload), (field) => map4(forEach(filter2(ensure(field[1]), (item) => item !== undefined), (item) => gen(function* () {
+    if (!is(File3)(item))
+      return coerce(item);
+    return filePart(yield* readFile(item), item.name, item.contentType);
+  })), (parts) => [field[0], parts]))));
+});
+function mediaBytes(media) {
+  if (is(File3)(media))
+    return map4(readFile(media), (bytes) => ({
+      bytes,
+      contentType: media.contentType
+    }));
+  return succeed4({
+    bytes: media.contentBase64,
+    contentType: getOrNull(fromNullishOr(media.contentType))
+  });
+}
+function isSafeUrl(value, origin) {
+  if (!URL.canParse(value))
+    return false;
+  const url = new URL(value);
+  return url.protocol === "https:" && url.username === "" && url.password === "" && (origin === undefined || url.origin === origin);
+}
+function refused(message) {
+  return fail5(ActionHandlerError.make({ message }));
+}
+function continuation2(request, nextLink) {
+  if (nextLink === undefined)
+    return succeed4(request);
+  const declared = new URL(request.url);
+  const next = URL.canParse(nextLink) ? new URL(nextLink) : undefined;
+  if (next === undefined || !isSafeUrl(nextLink) || next.pathname !== declared.pathname)
+    return refused("A continuation URL must be an HTTPS link to the same operation path");
+  return succeed4(makeWith(request.method, `${declared.origin}${next.pathname}${next.search}`, empty3, none(), request.headers, empty5));
+}
+function preauthenticated2(method, url, ...steps) {
+  if (!isSafeUrl(url))
+    return refused("An upload session requires a preauthenticated HTTPS URL");
+  return succeed4(reduce(steps, method(url), (request, step) => step(request)));
+}
+function failure(error) {
+  return is(ActionHandlerError)(error) ? error : fromHttpClientFailure(error);
+}
+function redirect(response) {
+  const location = response.headers["location"];
+  if (response.status < 300 || response.status >= 400 || location === undefined)
+    return;
+  const sent = response.request;
+  const url = new URL(location, sent.url);
+  const request = response.status === 303 && sent.method !== "GET" && sent.method !== "HEAD" || (response.status === 301 || response.status === 302) && sent.method === "POST" ? setBody(setMethod(sent, "GET"), empty5) : sent;
+  return url.origin === new URL(sent.url).origin ? setUrl(request, url) : setUrl(makeWith(request.method, "", empty3, none(), empty2, request.body), url);
+}
+function follow(client, response, redirects) {
+  const next = redirect(response);
+  return next === undefined || redirects === 10 ? succeed4(response) : flatMap3(client.execute(next), (result) => follow(client, result, redirects + 1));
+}
+function dispositionName(header) {
+  if (header === undefined)
+    return;
+  const encoded = pipe(match4(/(?:^|;)\s*filename\*\s*=\s*UTF-8'[^']*'([^;]+)/iu)(header), flatMap((match5) => fromUndefinedOr(match5[1])));
+  const decoded = pipe(encoded, flatMap((value) => liftThrowable(() => decodeURIComponent(trim(value)))()));
+  return getOrElse(decoded, () => pipe(match4(/(?:^|;)\s*filename\s*=\s*(?:"((?:\\.|[^"\\])*)"|([^;]*))/iu)(header), flatMap((match5) => orElse(map(fromUndefinedOr(match5[1]), (name) => replace(/\\(.)/gu, "$1")(name)), () => map(fromUndefinedOr(match5[2]), trim))), getOrUndefined));
+}
+var read2 = fnUntraced(function* (response, body) {
+  if (body === "json")
+    return yield* response.json;
+  if (body === "text")
+    return yield* response.text;
+  if (body === "void")
+    return {};
+  if (body === "unknown") {
+    const text = yield* response.text;
+    if (isEmpty(trim(text)))
+      return null;
+    return getOrElse(decodeOption(fromJsonString(Json))(text), () => text);
+  }
+  const bytes = new Uint8Array(yield* response.arrayBuffer);
+  const name = dispositionName(response.headers["content-disposition"]);
+  if (body === "file")
+    return yield* pipe(write({
+      bytes,
+      contentType: getOrNull(fromUndefinedOr(response.headers["content-type"])),
+      name: name ?? "file"
+    }), mapError(fileFailed));
+  return toolFile(bytes, response.headers["content-type"] ?? null, name ?? null);
+});
+function make2(auth) {
+  const { authorize, checkResponse = () => void_2 } = auth;
+  const send = fnUntraced(function* (context, request) {
+    const base = yield* HttpClient;
+    const uploadPolicy = context === undefined ? auth.preauthenticatedUploadUrl : undefined;
+    const client = uploadPolicy === undefined ? base : mapRequestEffect(base, (outgoing) => isSafeUrl(outgoing.url) && is(uploadPolicy)(outgoing.url) ? succeed4(outgoing) : fail5(new HttpClientError({ reason: new InvalidUrlError({
+      description: "The upload URL is not an approved provider HTTPS destination",
+      request: outgoing
+    }) })));
+    const transport = transformResponse(client, flatMap3((response) => follow(client, response, 0)));
+    const execution = (context === undefined ? transport : authorize(transport, context)).execute(isEffect(request) ? yield* request : request);
+    const options = yield* serviceOption(RequestInit);
+    const response = yield* match(uploadPolicy !== undefined, {
+      onFalse: () => execution,
+      onTrue: () => provideService(execution, RequestInit, {
+        ...getOrElse(options, () => ({})),
+        redirect: "manual"
+      })
+    });
+    if (response.status < 200 || response.status >= 300)
+      return yield* fail5({
+        cause: yield* response.text,
+        response
+      });
+    yield* checkResponse(response);
+    return response;
+  });
+  function endpoint(contract, run) {
+    if (!isSchema(contract.output)) {
+      const wire = contract.output.wire;
+      return {
+        input: contract.input,
+        output: toType(wire),
+        run: (input, context) => run(input, context, wire),
+        wire
+      };
+    }
+    const output = contract.output;
+    return {
+      input: contract.input,
+      output,
+      run: (input, context) => run(input, context, output)
+    };
+  }
+  function execute(context, output, request, body) {
+    return pipe(send(context, request), flatMap3((response) => read2(response, body)), flatMap3(decodeResponse(output)), mapError(failure));
+  }
+  const variants = fnUntraced(function* (context, output, request, declared, media) {
+    const response = yield* send(context, request);
+    const exact = flatMap2(declared, (variant) => variant.status === undefined ? [] : [variant.status]);
+    const contentType = pipe(response.headers["content-type"] ?? "", split(";"), headNonEmpty, trim, toLowerCase);
+    const ordered = sort(declared, mapInput(Number2, (variant) => {
+      if (variant.body === "void" || variant.body === "unknown")
+        return 3;
+      if (variant.contentType === "*/*")
+        return 2;
+      return pipe(variant.contentType, endsWith("/*")) ? 1 : 0;
+    }));
+    const variant = findFirst(ordered, (candidate) => {
+      if (!(candidate.status === undefined ? !contains2(exact, response.status) : candidate.status === response.status))
+        return false;
+      if (media !== undefined)
+        return (candidate.body === "binary" || candidate.body === "file") === media;
+      if (candidate.body === "void" || candidate.body === "unknown" || candidate.contentType === "*/*")
+        return true;
+      if (pipe(candidate.contentType, endsWith("/*")))
+        return pipe(contentType, startsWith(pipe(candidate.contentType, slice(0, -1))));
+      return contentType === candidate.contentType;
+    });
+    if (isNone(variant))
+      return yield* fail5({
+        cause: "The API returned an undeclared successful response",
+        response
+      });
+    const headers = flatMap2(variant.value.headers ?? [], (name) => {
+      const value = response.headers[toLowerCase(name)];
+      return value === undefined ? [] : [[name, value]];
+    });
+    return yield* decodeResponse(output)({
+      body: yield* read2(response, variant.value.body),
+      contentType: variant.value.contentType,
+      status: response.status,
+      ...variant.value.headers === undefined ? {} : { headers: fromEntries(headers) }
+    });
+  }, mapError(failure));
+  return {
+    endpoint,
+    execute,
+    googleUpload: fnUntraced(function* (context, output, request, payload, options) {
+      const client = authorize(yield* HttpClient, context);
+      const media = "media" in payload ? yield* mediaBytes(payload.media) : undefined;
+      const size = "totalBytes" in payload ? payload.totalBytes : media?.bytes.byteLength ?? 0;
+      if (size < 0 || options.maxSize !== undefined && size > options.maxSize)
+        return yield* refused("The upload size is outside the API's declared limit");
+      const origin = new URL(request.url).origin;
+      if (payload.mode === "start") {
+        if (options.resumable === undefined)
+          return yield* refused("This API has no resumable upload protocol");
+        const response = yield* client.execute(pipe(setUrl(request, options.resumable), setUrlParam("uploadType", "resumable"), setHeaders({
+          "x-upload-content-length": `${size}`,
+          "x-upload-content-type": payload.contentType
+        }), bodyJsonUnsafe(payload.metadata ?? {})));
+        if (response.status < 200 || response.status >= 300)
+          return yield* fail5({
+            cause: yield* response.text,
+            response
+          });
+        const sessionUrl = response.headers["location"];
+        if (sessionUrl === undefined || !isSafeUrl(sessionUrl, origin))
+          return yield* fail5({
+            cause: "The API returned an invalid upload session URL",
+            response
+          });
+        return yield* decodeResponse(output)({
+          nextOffset: 0,
+          sessionUrl,
+          state: "pending"
+        });
+      }
+      if (payload.mode === "chunk" || payload.mode === "status") {
+        if (!isSafeUrl(payload.sessionUrl, origin))
+          return yield* refused("The upload session URL must use the API's HTTPS origin");
+        const bytes = media?.bytes ?? /* @__PURE__ */ new Uint8Array;
+        const end = payload.mode === "chunk" ? payload.offset + bytes.byteLength : 0;
+        if (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");
+        const response = yield* client.execute(pipe(put(payload.sessionUrl), bodyUint8Array(bytes, media?.contentType ?? "application/octet-stream"), setHeader("content-range", payload.mode === "status" ? `bytes */${size}` : `bytes ${payload.offset}-${end - 1}/${size}`)));
+        if (response.status === 308) {
+          const range = response.headers["range"];
+          if (range !== undefined && !/^bytes=0-\d+$/u.test(range))
+            return yield* fail5({
+              cause: "The API returned an invalid upload range",
+              response
+            });
+          const nextOffset = range === undefined ? 0 : Number(pipe(range, slice(8))) + 1;
+          if (nextOffset > size)
+            return yield* fail5({
+              cause: "The API returned an upload offset beyond the total size",
+              response
+            });
+          return yield* decodeResponse(output)({
+            nextOffset,
+            sessionUrl: payload.sessionUrl,
+            state: "pending"
+          });
+        }
+        if (response.status < 200 || response.status >= 300)
+          return yield* fail5({
+            cause: yield* response.text,
+            response
+          });
+        return yield* decodeResponse(output)({
+          resource: yield* response.json,
+          state: "complete"
+        });
+      }
+      const selected = setUrlParam(request, "uploadType", payload.mode);
+      const bytes = media?.bytes ?? /* @__PURE__ */ new Uint8Array;
+      const contentType = media?.contentType ?? "application/octet-stream";
+      const boundary = `dual-${yield* nextInt}-${yield* nextInt}`;
+      const metadata = payload.mode === "multipart" ? yield* encodeEffect(fromJsonString(Unknown))(payload.metadata) : "";
+      const body = payload.mode === "media" ? bodyUint8Array(selected, bytes, contentType) : bodyUint8Array(selected, new Uint8Array(yield* promise(() => new Blob([
+        `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${metadata}\r
+--${boundary}\r
+Content-Type: ${contentType}\r
+\r
+`,
+        new Uint8Array(bytes),
+        `\r
+--${boundary}--\r
+`
+      ]).arrayBuffer())), `multipart/related; boundary=${boundary}`);
+      const response = yield* client.execute(body);
+      if (response.status < 200 || response.status >= 300)
+        return yield* fail5({
+          cause: yield* response.text,
+          response
+        });
+      return yield* decodeResponse(output)({
+        resource: yield* response.json,
+        state: "complete"
+      });
+    }, mapError(failure)),
+    graphql: fnUntraced(function* (context, output, request, field) {
+      const response = yield* send(context, request);
+      const body = yield* decodeUnknownEffect(GraphqlResponse)(yield* response.json);
+      if (body.errors !== undefined && isReadonlyArrayNonEmpty(body.errors))
+        return yield* ActionHandlerError.make({
+          details: body.errors,
+          message: join(map3(body.errors, (error) => error.message), "; ")
+        });
+      return yield* decodeResponse(output)(body.data?.[field]);
+    }, mapError(failure)),
+    mcp: fnUntraced(function* (context, output, server, tool, args, structured) {
+      const connection = yield* connect(authorize(yield* HttpClient, context), server, {});
+      const result = yield* decodeUnknownEffect(CallToolResult)(yield* connection.request("tools/call", {
+        arguments: args,
+        name: tool
+      }));
+      if (result.isError === true)
+        return yield* ActionHandlerError.make({
+          details: result.content,
+          message: join(flatMap2(result.content, (block) => fromNullishOr2(block.text)), `
+`)
+        });
+      return yield* decodeResponse(output)(match(structured, {
+        onFalse: () => ({ content: result.content }),
+        onTrue: () => result.structuredContent
+      }));
+    }, scoped, mapError((error) => is(McpError)(error) ? ActionHandlerError.make({ message: error.message }) : failure(error))),
+    variants
+  };
+}
+
+// dist/auth.js
+var auth_exports2 = /* @__PURE__ */ __exportAll2({
+  Auth: () => auth_exports2,
+  authMethods: () => authMethods2,
+  authorize: () => authorize2
+});
+var authMethods2 = [AuthMethod_exports.make("api-token", {
+  description: "Authenticate with a Notion internal integration token sent as a bearer token",
+  name: "Notion internal integration token",
+  schema: Struct({ token: NonEmptyString })
+}), AuthMethod_exports.oauth2("oauth2", {
+  authorizationParams: { owner: "user" },
+  authorizationUrl: "https://api.notion.com/v1/oauth/authorize",
+  client: (options) => ({
+    authentication: "basic",
+    clientId: options.setup.clientId,
+    clientSecret: options.setup.clientSecret
+  }),
+  description: "Authenticate with Notion through a public integration using OAuth2",
+  material: AuthMethod_exports.OAuth2TokenMaterial,
+  name: "Notion OAuth2",
+  pkce: false,
+  scopes: [],
+  setup: Struct({
+    clientId: String3,
+    clientSecret: String3
+  }),
+  tokenHeaders: { "Notion-Version": "2026-03-11" },
+  tokenRequestEncoding: "json",
+  tokenUrl: "https://api.notion.com/v1/oauth/token"
+})];
+function authorize2(client, context) {
+  return pipe(value2(context.auth.current), discriminatorsExhaustive("methodId")({
+    "api-token": (binding) => mapRequest(client, bearerToken(binding.value.token)),
+    oauth2: (binding) => mapRequest(client, bearerToken(binding.value.accessToken))
+  }), mapRequest(setHeader("Notion-Version", "2026-03-11")));
+}
+export { match, Http_exports, File2, FileFromBase642, FileFromBase64Url2, Base64FromFile2, Base64UrlFromFile2, FileFromDataUri2, DataUriFromFile2, DateTimeFromUnixSeconds2, UnixSecondsFromDateTime2, DateTimeFromRfc28222, Rfc2822FromDateTime2, decoded2, path2, literal2, segments2, params2, form2, continuation2, preauthenticated2, auth_exports2, authMethods2, authorize2 };
+
+//# debugId=A074507D9F5318F264756E2164756E21
+//# sourceMappingURL=plugin-529jjg5q.js.map