apps 0.0.1-beta.1 → 0.0.1-beta.11

package/js/{chunk-NCYXZN2G.js → chunk-UVL56Z6E.js}

@@ -1,3 +1,41 @@
+import {
+  __export
+} from "./chunk-CZ7CSFO4.js";
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  Alias: () => Alias,
+  CST: () => cst_exports,
+  Composer: () => Composer,
+  Document: () => Document,
+  Lexer: () => Lexer,
+  LineCounter: () => LineCounter,
+  Pair: () => Pair,
+  Parser: () => Parser,
+  Scalar: () => Scalar,
+  Schema: () => Schema,
+  YAMLError: () => YAMLError,
+  YAMLMap: () => YAMLMap,
+  YAMLParseError: () => YAMLParseError,
+  YAMLSeq: () => YAMLSeq,
+  YAMLWarning: () => YAMLWarning,
+  isAlias: () => isAlias,
+  isCollection: () => isCollection,
+  isDocument: () => isDocument,
+  isMap: () => isMap,
+  isNode: () => isNode,
+  isPair: () => isPair,
+  isScalar: () => isScalar,
+  isSeq: () => isSeq,
+  parse: () => parse,
+  parseAllDocuments: () => parseAllDocuments,
+  parseDocument: () => parseDocument,
+  stringify: () => stringify3,
+  visit: () => visit,
+  visitAsync: () => visitAsync
+});
+
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/nodes/identity.js
 var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
 var DOC = /* @__PURE__ */ Symbol.for("yaml.document");
@@ -4632,30 +4670,251 @@ ${end.comment}` : end.comment;
   }
 };
 
-// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/line-counter.js
-var LineCounter = class {
-  constructor() {
-    this.lineStarts = [];
-    this.addNewLine = (offset) => this.lineStarts.push(offset);
-    this.linePos = (offset) => {
-      let low = 0;
-      let high = this.lineStarts.length;
-      while (low < high) {
-        const mid = low + high >> 1;
-        if (this.lineStarts[mid] < offset)
-          low = mid + 1;
-        else
-          high = mid;
-      }
-      if (this.lineStarts[low] === offset)
-        return { line: low + 1, col: 1 };
-      if (low === 0)
-        return { line: 0, col: offset };
-      const start = this.lineStarts[low - 1];
-      return { line: low, col: offset - start + 1 };
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst.js
+var cst_exports = {};
+__export(cst_exports, {
+  BOM: () => BOM,
+  DOCUMENT: () => DOCUMENT,
+  FLOW_END: () => FLOW_END,
+  SCALAR: () => SCALAR2,
+  createScalarToken: () => createScalarToken,
+  isCollection: () => isCollection2,
+  isScalar: () => isScalar2,
+  prettyToken: () => prettyToken,
+  resolveAsScalar: () => resolveAsScalar,
+  setScalarValue: () => setScalarValue,
+  stringify: () => stringify2,
+  tokenType: () => tokenType,
+  visit: () => visit2
+});
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-scalar.js
+function resolveAsScalar(token, strict = true, onError) {
+  if (token) {
+    const _onError = (pos, code, message) => {
+      const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+      if (onError)
+        onError(offset, code, message);
+      else
+        throw new YAMLParseError([offset, offset + 1], code, message);
     };
+    switch (token.type) {
+      case "scalar":
+      case "single-quoted-scalar":
+      case "double-quoted-scalar":
+        return resolveFlowScalar(token, strict, _onError);
+      case "block-scalar":
+        return resolveBlockScalar({ options: { strict } }, token, _onError);
+    }
   }
-};
+  return null;
+}
+function createScalarToken(value, context) {
+  const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+  const source = stringifyString({ type, value }, {
+    implicitKey,
+    indent: indent > 0 ? " ".repeat(indent) : "",
+    inFlow,
+    options: { blockQuote: true, lineWidth: -1 }
+  });
+  const end = context.end ?? [
+    { type: "newline", offset: -1, indent, source: "\n" }
+  ];
+  switch (source[0]) {
+    case "|":
+    case ">": {
+      const he = source.indexOf("\n");
+      const head = source.substring(0, he);
+      const body = source.substring(he + 1) + "\n";
+      const props = [
+        { type: "block-scalar-header", offset, indent, source: head }
+      ];
+      if (!addEndtoBlockProps(props, end))
+        props.push({ type: "newline", offset: -1, indent, source: "\n" });
+      return { type: "block-scalar", offset, indent, props, source: body };
+    }
+    case '"':
+      return { type: "double-quoted-scalar", offset, indent, source, end };
+    case "'":
+      return { type: "single-quoted-scalar", offset, indent, source, end };
+    default:
+      return { type: "scalar", offset, indent, source, end };
+  }
+}
+function setScalarValue(token, value, context = {}) {
+  let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+  let indent = "indent" in token ? token.indent : null;
+  if (afterKey && typeof indent === "number")
+    indent += 2;
+  if (!type)
+    switch (token.type) {
+      case "single-quoted-scalar":
+        type = "QUOTE_SINGLE";
+        break;
+      case "double-quoted-scalar":
+        type = "QUOTE_DOUBLE";
+        break;
+      case "block-scalar": {
+        const header = token.props[0];
+        if (header.type !== "block-scalar-header")
+          throw new Error("Invalid block scalar header");
+        type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL";
+        break;
+      }
+      default:
+        type = "PLAIN";
+    }
+  const source = stringifyString({ type, value }, {
+    implicitKey: implicitKey || indent === null,
+    indent: indent !== null && indent > 0 ? " ".repeat(indent) : "",
+    inFlow,
+    options: { blockQuote: true, lineWidth: -1 }
+  });
+  switch (source[0]) {
+    case "|":
+    case ">":
+      setBlockScalarValue(token, source);
+      break;
+    case '"':
+      setFlowScalarValue(token, source, "double-quoted-scalar");
+      break;
+    case "'":
+      setFlowScalarValue(token, source, "single-quoted-scalar");
+      break;
+    default:
+      setFlowScalarValue(token, source, "scalar");
+  }
+}
+function setBlockScalarValue(token, source) {
+  const he = source.indexOf("\n");
+  const head = source.substring(0, he);
+  const body = source.substring(he + 1) + "\n";
+  if (token.type === "block-scalar") {
+    const header = token.props[0];
+    if (header.type !== "block-scalar-header")
+      throw new Error("Invalid block scalar header");
+    header.source = head;
+    token.source = body;
+  } else {
+    const { offset } = token;
+    const indent = "indent" in token ? token.indent : -1;
+    const props = [
+      { type: "block-scalar-header", offset, indent, source: head }
+    ];
+    if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0))
+      props.push({ type: "newline", offset: -1, indent, source: "\n" });
+    for (const key of Object.keys(token))
+      if (key !== "type" && key !== "offset")
+        delete token[key];
+    Object.assign(token, { type: "block-scalar", indent, props, source: body });
+  }
+}
+function addEndtoBlockProps(props, end) {
+  if (end)
+    for (const st of end)
+      switch (st.type) {
+        case "space":
+        case "comment":
+          props.push(st);
+          break;
+        case "newline":
+          props.push(st);
+          return true;
+      }
+  return false;
+}
+function setFlowScalarValue(token, source, type) {
+  switch (token.type) {
+    case "scalar":
+    case "double-quoted-scalar":
+    case "single-quoted-scalar":
+      token.type = type;
+      token.source = source;
+      break;
+    case "block-scalar": {
+      const end = token.props.slice(1);
+      let oa = source.length;
+      if (token.props[0].type === "block-scalar-header")
+        oa -= token.props[0].source.length;
+      for (const tok of end)
+        tok.offset += oa;
+      delete token.props;
+      Object.assign(token, { type, source, end });
+      break;
+    }
+    case "block-map":
+    case "block-seq": {
+      const offset = token.offset + source.length;
+      const nl = { type: "newline", offset, indent: token.indent, source: "\n" };
+      delete token.items;
+      Object.assign(token, { type, source, end: [nl] });
+      break;
+    }
+    default: {
+      const indent = "indent" in token ? token.indent : -1;
+      const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : [];
+      for (const key of Object.keys(token))
+        if (key !== "type" && key !== "offset")
+          delete token[key];
+      Object.assign(token, { type, indent, source, end });
+    }
+  }
+}
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-stringify.js
+var stringify2 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
+function stringifyToken(token) {
+  switch (token.type) {
+    case "block-scalar": {
+      let res = "";
+      for (const tok of token.props)
+        res += stringifyToken(tok);
+      return res + token.source;
+    }
+    case "block-map":
+    case "block-seq": {
+      let res = "";
+      for (const item of token.items)
+        res += stringifyItem(item);
+      return res;
+    }
+    case "flow-collection": {
+      let res = token.start.source;
+      for (const item of token.items)
+        res += stringifyItem(item);
+      for (const st of token.end)
+        res += st.source;
+      return res;
+    }
+    case "document": {
+      let res = stringifyItem(token);
+      if (token.end)
+        for (const st of token.end)
+          res += st.source;
+      return res;
+    }
+    default: {
+      let res = token.source;
+      if ("end" in token && token.end)
+        for (const st of token.end)
+          res += st.source;
+      return res;
+    }
+  }
+}
+function stringifyItem({ start, key, sep, value }) {
+  let res = "";
+  for (const st of start)
+    res += st.source;
+  if (key)
+    res += stringifyToken(key);
+  if (sep)
+    for (const st of sep)
+      res += st.source;
+  if (value)
+    res += stringifyToken(value);
+  return res;
+}
 
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/cst-visit.js
 var BREAK2 = /* @__PURE__ */ Symbol("break visit");
@@ -4718,6 +4977,22 @@ var BOM = "\uFEFF";
 var DOCUMENT = "";
 var FLOW_END = "";
 var SCALAR2 = "";
+var isCollection2 = (token) => !!token && "items" in token;
+var isScalar2 = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+function prettyToken(token) {
+  switch (token) {
+    case BOM:
+      return "<BOM>";
+    case DOCUMENT:
+      return "<DOC>";
+    case FLOW_END:
+      return "<FLOW_END>";
+    case SCALAR2:
+      return "<SCALAR>";
+    default:
+      return JSON.stringify(token);
+  }
+}
 function tokenType(source) {
   switch (source) {
     case BOM:
@@ -5360,6 +5635,31 @@ var Lexer = class {
   }
 };
 
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/line-counter.js
+var LineCounter = class {
+  constructor() {
+    this.lineStarts = [];
+    this.addNewLine = (offset) => this.lineStarts.push(offset);
+    this.linePos = (offset) => {
+      let low = 0;
+      let high = this.lineStarts.length;
+      while (low < high) {
+        const mid = low + high >> 1;
+        if (this.lineStarts[mid] < offset)
+          low = mid + 1;
+        else
+          high = mid;
+      }
+      if (this.lineStarts[low] === offset)
+        return { line: low + 1, col: 1 };
+      if (low === 0)
+        return { line: 0, col: offset };
+      const start = this.lineStarts[low - 1];
+      return { line: low, col: offset - start + 1 };
+    };
+  }
+};
+
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/dist/parse/parser.js
 function includesToken(list, type) {
   for (let i = 0; i < list.length; ++i)
@@ -6229,6 +6529,20 @@ function parseOptions(options) {
   const lineCounter = options.lineCounter || prettyErrors && new LineCounter() || null;
   return { lineCounter, prettyErrors };
 }
+function parseAllDocuments(source, options = {}) {
+  const { lineCounter, prettyErrors } = parseOptions(options);
+  const parser = new Parser(lineCounter?.addNewLine);
+  const composer = new Composer(options);
+  const docs = Array.from(composer.compose(parser.parse(source)));
+  if (prettyErrors && lineCounter)
+    for (const doc of docs) {
+      doc.errors.forEach(prettifyError(source, lineCounter));
+      doc.warnings.forEach(prettifyError(source, lineCounter));
+    }
+  if (docs.length > 0)
+    return docs;
+  return Object.assign([], { empty: true }, composer.streamInfo());
+}
 function parseDocument(source, options = {}) {
   const { lineCounter, prettyErrors } = parseOptions(options);
   const parser = new Parser(lineCounter?.addNewLine);
@@ -6267,8 +6581,61 @@ function parse(src, reviver, options) {
   }
   return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
+function stringify3(value, replacer, options) {
+  let _replacer = null;
+  if (typeof replacer === "function" || Array.isArray(replacer)) {
+    _replacer = replacer;
+  } else if (options === void 0 && replacer) {
+    options = replacer;
+  }
+  if (typeof options === "string")
+    options = options.length;
+  if (typeof options === "number") {
+    const indent = Math.round(options);
+    options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent };
+  }
+  if (value === void 0) {
+    const { keepUndefined } = options ?? replacer ?? {};
+    if (!keepUndefined)
+      return void 0;
+  }
+  if (isDocument(value) && !_replacer)
+    return value.toString(options);
+  return new Document(value, _replacer, options).toString(options);
+}
+
+// ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/browser/index.js
+var browser_default = dist_exports;
 
 export {
+  isAlias,
+  isDocument,
+  isMap,
+  isPair,
+  isScalar,
+  isSeq,
+  isCollection,
+  isNode,
+  visit,
+  visitAsync,
+  Alias,
+  Scalar,
+  Pair,
+  YAMLMap,
+  YAMLSeq,
+  Schema,
+  Document,
+  YAMLError,
+  YAMLParseError,
+  YAMLWarning,
+  Composer,
+  cst_exports,
+  Lexer,
+  LineCounter,
+  Parser,
+  parseAllDocuments,
   parseDocument,
-  parse
+  parse,
+  stringify3 as stringify,
+  browser_default
 };

package/js/{chunk-4LPG6RCH.js → chunk-VFZKSM3T.js}

@@ -1,14 +1,6 @@
-import {
-  HttpApiEndpoint_exports,
-  HttpApiGroup_exports,
-  HttpApi_exports,
-  UiFailed,
-  UiForbidden,
-  UiUnauthorized
-} from "./chunk-OHRT55C4.js";
 import {
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/contracts/ui-auth.ts
 var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(
@@ -31,26 +23,14 @@ var AppReturnPath = Schema_exports.String.check(
   })
 ).pipe(Schema_exports.brand("AppReturnPath"));
 var AppSignInCallback = Schema_exports.Struct({ request: AppSignInId, code: AppSignInCode });
-var AppSignInApi = HttpApi_exports.make("app-sign-in").add(
-  HttpApiGroup_exports.make("appSignIn").add(
-    HttpApiEndpoint_exports.post("start", "/_executor/auth/start", {
-      payload: Schema_exports.Struct({ returnTo: AppReturnPath }),
-      success: Schema_exports.Struct({ url: Schema_exports.String }),
-      error: [UiForbidden, UiFailed]
-    })
-  ).add(
-    HttpApiEndpoint_exports.post("complete", "/_executor/auth/complete", {
-      payload: AppSignInCallback,
-      success: Schema_exports.Struct({ returnTo: AppReturnPath }),
-      error: [UiUnauthorized, UiForbidden, UiFailed]
-    })
-  )
-);
+var appSignInCallbackPath = "/_executor/auth/callback";
+var AppSignInFailure = Schema_exports.Literals(["ended", "forbidden", "unavailable"]);
 
 export {
   AppSignInId,
   AppSignInCode,
   AppReturnPath,
   AppSignInCallback,
-  AppSignInApi
+  appSignInCallbackPath,
+  AppSignInFailure
 };

package/js/{chunk-6IIO4NPI.js → chunk-WVVV4TX2.js}

@@ -1,13 +1,17 @@
 import {
-  operationDeclaration
-} from "./chunk-PZ36XMXW.js";
+  fixedRouter
+} from "./chunk-Z2QY3YTF.js";
+import {
+  nativeOperation,
+  operationDeclaration,
+  routerDeclaration
+} from "./chunk-GPFVWWDZ.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
-  const queries = {};
-  const mutations = {};
+  const declared = {};
   for (const [name, operation] of Object.entries(operations)) {
-    const kind = Object.hasOwn(kinds, name) ? kinds[name] : operation.readOnly === true ? "query" : "mutation";
+    const kind = Object.hasOwn(kinds, name) ? kinds[name] ?? "mutation" : operation.readOnly === true ? "query" : "mutation";
     const native = {
       description: operation.description,
       ...operation.title === void 0 ? {} : { title: operation.title },
@@ -18,12 +22,20 @@ var protocolOperations = (operations, kinds = {}) => {
     };
     const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
     const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
-    if (kind === "query") queries[name] = operationDeclaration(withOutput({ ...native, kind }));
-    else mutations[name] = operationDeclaration(withOutput({ ...native, kind: "mutation" }));
+    declared[name] = operationDeclaration(withOutput({ ...native, kind }));
+  }
+  return declared;
+};
+var protocolRouter = (operations, kinds = {}) => {
+  const native = {};
+  for (const [name, declaration] of Object.entries(protocolOperations(operations, kinds))) {
+    const operation = nativeOperation(declaration);
+    if (operation !== void 0) native[name] = operation;
   }
-  return { queries, mutations };
+  return routerDeclaration(fixedRouter(native));
 };
 
 export {
-  protocolOperations
+  protocolOperations,
+  protocolRouter
 };

package/js/{chunk-G7IE6BKC.js → chunk-YBRC463S.js}

@@ -2,36 +2,36 @@ import {
   adaptMcpTools,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-X7SFGU4Q.js";
+} from "./chunk-EFAPIRVB.js";
 import {
   accountProviderError,
   httpProviderError
-} from "./chunk-ZJWDMTE3.js";
+} from "./chunk-MKWZPDR6.js";
 import {
   McpError,
   McpToolsOptions,
   defaultMcpClientLimits
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-KRSCJDTW.js";
 import {
   ProviderError
-} from "./chunk-W7D7WVSY.js";
+} from "./chunk-R3EV5FTO.js";
 import {
   captureTelemetry
-} from "./chunk-ZCAMUXSG.js";
+} from "./chunk-ODEIDRGW.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-HDJH3RPR.js";
+} from "./chunk-57RKNWL2.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-UK573G7W.js";
 import {
   Deferred_exports,
   Effect_exports,
   Redacted_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/implementation/mcp.ts
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";