@cremini/skillpack 1.2.5 → 1.2.7

package/dist/cli.js

@@ -329,6 +329,20 @@ var init_commands = __esm({
   }
 });
 
+// src/runtime/adapters/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isMessageSender: () => isMessageSender
+});
+function isMessageSender(adapter) {
+  return typeof adapter.sendMessage === "function";
+}
+var init_types = __esm({
+  "src/runtime/adapters/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -449,7 +463,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs12 from "fs";
+import fs13 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -469,12 +483,14 @@ var init_telegram = __esm({
       agent = null;
       options;
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.bot = new TelegramBot(this.options.token, { polling: true });
         this.bot.on("message", (msg) => {
           this.handleTelegramMessage(msg).catch((err) => {
@@ -516,6 +532,15 @@ var init_telegram = __esm({
         const messageId = msg.message_id;
         const text = (msg.text || msg.caption || "").trim();
         const channelId = `telegram-${chatId}`;
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "telegram",
+          {
+            id: String(msg.from?.id || ""),
+            username: msg.from?.username || msg.from?.first_name || ""
+          },
+          text
+        );
         const attachments = await this.extractAttachments(msg, channelId);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(chatId, messageId);
@@ -545,6 +570,7 @@ var init_telegram = __esm({
               });
               break;
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const userText = text || "(User sent an attachment)";
@@ -755,7 +781,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs12.existsSync(filePath)) {
+          if (!fs13.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -775,8 +801,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
@@ -807,12 +833,14 @@ var init_slack = __esm({
       botUserId = null;
       lastThreadByChannel = /* @__PURE__ */ new Map();
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.app = new App({
           token: this.options.botToken,
           appToken: this.options.appToken,
@@ -898,6 +926,15 @@ var init_slack = __esm({
         const teamId = this.getTeamId(body, context);
         const channelId = `slack-dm-${teamId}-${event.channel}`;
         const route = { channel: event.channel };
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(client, event);
@@ -928,6 +965,15 @@ var init_slack = __esm({
           threadTs
         );
         const text = this.stripBotMention(event.text || "").trim();
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) {
           await this.sendSafe(
@@ -987,6 +1033,7 @@ var init_slack = __esm({
               caption: event.caption
             });
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const result = await this.agent.handleMessage(
@@ -1390,12 +1437,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs13.existsSync(filePath)) {
+          if (!fs14.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path12.basename(filePath);
-          const fileContent = fs13.readFileSync(filePath);
+          const filename = path13.basename(filePath);
+          const fileContent = fs14.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1412,20 +1459,6 @@ var init_slack = __esm({
   }
 });
 
-// src/runtime/adapters/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isMessageSender: () => isMessageSender
-});
-function isMessageSender(adapter) {
-  return typeof adapter.sendMessage === "function";
-}
-var init_types = __esm({
-  "src/runtime/adapters/types.ts"() {
-    "use strict";
-  }
-});
-
 // src/runtime/adapters/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -2436,15 +2469,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path14 from "path";
-import fs15 from "fs";
+import path15 from "path";
+import fs16 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path13 from "path";
-import fs14 from "fs";
+import path14 from "path";
+import fs15 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -2467,2734 +2500,128 @@ import {
 // src/runtime/tools/send-file-tool.ts
 import fs7 from "fs";
 import path7 from "path";
-
-// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
-var value_exports = {};
-__export(value_exports, {
-  HasPropertyKey: () => HasPropertyKey,
-  IsArray: () => IsArray,
-  IsAsyncIterator: () => IsAsyncIterator,
-  IsBigInt: () => IsBigInt,
-  IsBoolean: () => IsBoolean,
-  IsDate: () => IsDate,
-  IsFunction: () => IsFunction,
-  IsIterator: () => IsIterator,
-  IsNull: () => IsNull,
-  IsNumber: () => IsNumber,
-  IsObject: () => IsObject,
-  IsRegExp: () => IsRegExp,
-  IsString: () => IsString,
-  IsSymbol: () => IsSymbol,
-  IsUint8Array: () => IsUint8Array,
-  IsUndefined: () => IsUndefined
+import { Type } from "@sinclair/typebox";
+var SendFileParams = Type.Object({
+  filePath: Type.String({
+    description: "Absolute path to the file to send to the user. The file must exist and be readable."
+  }),
+  caption: Type.Optional(
+    Type.String({
+      description: "Optional caption or description to accompany the file."
+    })
+  )
 });
-function HasPropertyKey(value, key) {
-  return key in value;
-}
-function IsAsyncIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
-}
-function IsArray(value) {
-  return Array.isArray(value);
-}
-function IsBigInt(value) {
-  return typeof value === "bigint";
-}
-function IsBoolean(value) {
-  return typeof value === "boolean";
-}
-function IsDate(value) {
-  return value instanceof globalThis.Date;
-}
-function IsFunction(value) {
-  return typeof value === "function";
-}
-function IsIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
-}
-function IsNull(value) {
-  return value === null;
-}
-function IsNumber(value) {
-  return typeof value === "number";
-}
-function IsObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function IsRegExp(value) {
-  return value instanceof globalThis.RegExp;
-}
-function IsString(value) {
-  return typeof value === "string";
-}
-function IsSymbol(value) {
-  return typeof value === "symbol";
-}
-function IsUint8Array(value) {
-  return value instanceof globalThis.Uint8Array;
-}
-function IsUndefined(value) {
-  return value === void 0;
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
-function ArrayType(value) {
-  return value.map((value2) => Visit(value2));
-}
-function DateType(value) {
-  return new Date(value.getTime());
-}
-function Uint8ArrayType(value) {
-  return new Uint8Array(value);
-}
-function RegExpType(value) {
-  return new RegExp(value.source, value.flags);
-}
-function ObjectType(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Visit(value[key]);
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Visit(value[key]);
-  }
-  return result;
-}
-function Visit(value) {
-  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
-}
-function Clone(value) {
-  return Visit(value);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
-function CloneType(schema, options) {
-  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
-}
-
-// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
-function IsObject2(value) {
-  return value !== null && typeof value === "object";
-}
-function IsArray2(value) {
-  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
-}
-function IsUndefined2(value) {
-  return value === void 0;
-}
-function IsNumber2(value) {
-  return typeof value === "number";
-}
-
-// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
-var TypeSystemPolicy;
-(function(TypeSystemPolicy2) {
-  TypeSystemPolicy2.InstanceMode = "default";
-  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
-  TypeSystemPolicy2.AllowArrayObject = false;
-  TypeSystemPolicy2.AllowNaN = false;
-  TypeSystemPolicy2.AllowNullVoid = false;
-  function IsExactOptionalProperty(value, key) {
-    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
-  }
-  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
-  function IsObjectLike(value) {
-    const isObject = IsObject2(value);
-    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
-  }
-  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
-  function IsRecordLike(value) {
-    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
-  }
-  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
-  function IsNumberLike(value) {
-    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
-  }
-  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
-  function IsVoidLike(value) {
-    const isUndefined = IsUndefined2(value);
-    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
-  }
-  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
-})(TypeSystemPolicy || (TypeSystemPolicy = {}));
-
-// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
-function ImmutableArray(value) {
-  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
-}
-function ImmutableDate(value) {
-  return value;
-}
-function ImmutableUint8Array(value) {
-  return value;
-}
-function ImmutableRegExp(value) {
-  return value;
-}
-function ImmutableObject(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Immutable(value[key]);
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Immutable(value[key]);
-  }
-  return globalThis.Object.freeze(result);
-}
-function Immutable(value) {
-  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
-function CreateType(schema, options) {
-  const result = options !== void 0 ? { ...options, ...schema } : schema;
-  switch (TypeSystemPolicy.InstanceMode) {
-    case "freeze":
-      return Immutable(result);
-    case "clone":
-      return Clone(result);
-    default:
-      return result;
-  }
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
-var TypeBoxError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".xml": "application/xml",
+  ".zip": "application/zip",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg"
 };
-
-// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = /* @__PURE__ */ Symbol.for("TypeBox.Transform");
-var ReadonlyKind = /* @__PURE__ */ Symbol.for("TypeBox.Readonly");
-var OptionalKind = /* @__PURE__ */ Symbol.for("TypeBox.Optional");
-var Hint = /* @__PURE__ */ Symbol.for("TypeBox.Hint");
-var Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
-
-// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
-function IsReadonly(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
-}
-function IsAny(value) {
-  return IsKindOf(value, "Any");
-}
-function IsArgument(value) {
-  return IsKindOf(value, "Argument");
-}
-function IsArray3(value) {
-  return IsKindOf(value, "Array");
-}
-function IsAsyncIterator2(value) {
-  return IsKindOf(value, "AsyncIterator");
-}
-function IsBigInt2(value) {
-  return IsKindOf(value, "BigInt");
-}
-function IsBoolean2(value) {
-  return IsKindOf(value, "Boolean");
-}
-function IsComputed(value) {
-  return IsKindOf(value, "Computed");
-}
-function IsConstructor(value) {
-  return IsKindOf(value, "Constructor");
-}
-function IsDate2(value) {
-  return IsKindOf(value, "Date");
-}
-function IsFunction2(value) {
-  return IsKindOf(value, "Function");
-}
-function IsInteger(value) {
-  return IsKindOf(value, "Integer");
-}
-function IsIntersect(value) {
-  return IsKindOf(value, "Intersect");
-}
-function IsIterator2(value) {
-  return IsKindOf(value, "Iterator");
-}
-function IsKindOf(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralValue(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
-}
-function IsLiteral(value) {
-  return IsKindOf(value, "Literal");
-}
-function IsMappedKey(value) {
-  return IsKindOf(value, "MappedKey");
-}
-function IsMappedResult(value) {
-  return IsKindOf(value, "MappedResult");
-}
-function IsNever(value) {
-  return IsKindOf(value, "Never");
-}
-function IsNot(value) {
-  return IsKindOf(value, "Not");
-}
-function IsNull2(value) {
-  return IsKindOf(value, "Null");
-}
-function IsNumber3(value) {
-  return IsKindOf(value, "Number");
-}
-function IsObject3(value) {
-  return IsKindOf(value, "Object");
-}
-function IsPromise(value) {
-  return IsKindOf(value, "Promise");
-}
-function IsRecord(value) {
-  return IsKindOf(value, "Record");
-}
-function IsRef(value) {
-  return IsKindOf(value, "Ref");
-}
-function IsRegExp2(value) {
-  return IsKindOf(value, "RegExp");
-}
-function IsString2(value) {
-  return IsKindOf(value, "String");
-}
-function IsSymbol2(value) {
-  return IsKindOf(value, "Symbol");
-}
-function IsTemplateLiteral(value) {
-  return IsKindOf(value, "TemplateLiteral");
-}
-function IsThis(value) {
-  return IsKindOf(value, "This");
-}
-function IsTransform(value) {
-  return IsObject(value) && TransformKind in value;
-}
-function IsTuple(value) {
-  return IsKindOf(value, "Tuple");
-}
-function IsUndefined3(value) {
-  return IsKindOf(value, "Undefined");
-}
-function IsUnion(value) {
-  return IsKindOf(value, "Union");
-}
-function IsUint8Array2(value) {
-  return IsKindOf(value, "Uint8Array");
-}
-function IsUnknown(value) {
-  return IsKindOf(value, "Unknown");
-}
-function IsUnsafe(value) {
-  return IsKindOf(value, "Unsafe");
-}
-function IsVoid(value) {
-  return IsKindOf(value, "Void");
-}
-function IsKind(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]);
+function detectMimeType(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext];
 }
-function IsSchema(value) {
-  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+function createSendFileTool(fileOutputCallbackRef) {
+  return {
+    name: "send_file",
+    label: "Send File",
+    description: "Send a file to the user via the current chat channel (Telegram, Slack, or Web). IMPORTANT: Do NOT proactively send files. Only use this tool when the user EXPLICITLY asks you to send, share, or deliver a file (e.g. '\u628A\u6587\u4EF6\u53D1\u7ED9\u6211', 'send me the file', 'share the result'). Never send intermediate/temporary files. When the user asks, send only the specific file(s) the user requested, not all generated files.",
+    promptSnippet: "send_file: Send a file to the user ONLY when they explicitly request it. Never send files proactively or automatically.",
+    parameters: SendFileParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const { filePath, caption } = params;
+      if (!fs7.existsSync(filePath)) {
+        return {
+          content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
+          details: void 0
+        };
+      }
+      const stats = fs7.statSync(filePath);
+      if (!stats.isFile()) {
+        return {
+          content: [
+            { type: "text", text: `Error: Path is not a file: ${filePath}` }
+          ],
+          details: void 0
+        };
+      }
+      const filename = path7.basename(filePath);
+      const mimeType = detectMimeType(filePath);
+      const callback = fileOutputCallbackRef.current;
+      if (callback) {
+        callback({
+          type: "file_output",
+          filePath,
+          filename,
+          mimeType,
+          caption
+        });
+      }
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `File "${filename}" (${sizeKB}KB) has been sent to the user.`
+          }
+        ],
+        details: void 0
+      };
+    }
+  };
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
-var type_exports = {};
-__export(type_exports, {
-  IsAny: () => IsAny2,
-  IsArgument: () => IsArgument2,
-  IsArray: () => IsArray4,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsBigInt: () => IsBigInt3,
-  IsBoolean: () => IsBoolean3,
-  IsComputed: () => IsComputed2,
-  IsConstructor: () => IsConstructor2,
-  IsDate: () => IsDate3,
-  IsFunction: () => IsFunction3,
-  IsImport: () => IsImport,
-  IsInteger: () => IsInteger2,
-  IsIntersect: () => IsIntersect2,
-  IsIterator: () => IsIterator3,
-  IsKind: () => IsKind2,
-  IsKindOf: () => IsKindOf2,
-  IsLiteral: () => IsLiteral2,
-  IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteralNumber: () => IsLiteralNumber,
-  IsLiteralString: () => IsLiteralString,
-  IsLiteralValue: () => IsLiteralValue2,
-  IsMappedKey: () => IsMappedKey2,
-  IsMappedResult: () => IsMappedResult2,
-  IsNever: () => IsNever2,
-  IsNot: () => IsNot2,
-  IsNull: () => IsNull3,
-  IsNumber: () => IsNumber4,
-  IsObject: () => IsObject4,
-  IsOptional: () => IsOptional2,
-  IsPromise: () => IsPromise2,
-  IsProperties: () => IsProperties,
-  IsReadonly: () => IsReadonly2,
-  IsRecord: () => IsRecord2,
-  IsRecursive: () => IsRecursive,
-  IsRef: () => IsRef2,
-  IsRegExp: () => IsRegExp3,
-  IsSchema: () => IsSchema2,
-  IsString: () => IsString3,
-  IsSymbol: () => IsSymbol3,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsThis: () => IsThis2,
-  IsTransform: () => IsTransform2,
-  IsTuple: () => IsTuple2,
-  IsUint8Array: () => IsUint8Array3,
-  IsUndefined: () => IsUndefined4,
-  IsUnion: () => IsUnion2,
-  IsUnionLiteral: () => IsUnionLiteral,
-  IsUnknown: () => IsUnknown2,
-  IsUnsafe: () => IsUnsafe2,
-  IsVoid: () => IsVoid2,
-  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
+// src/runtime/tools/manage-schedule-tool.ts
+import { Type as Type2 } from "@sinclair/typebox";
+var ManageScheduleParams = Type2.Object({
+  action: Type2.Union(
+    [
+      Type2.Literal("add"),
+      Type2.Literal("list"),
+      Type2.Literal("remove"),
+      Type2.Literal("trigger"),
+      Type2.Literal("enable"),
+      Type2.Literal("disable")
+    ],
+    { description: "The action to perform." }
+  ),
+  name: Type2.Optional(
+    Type2.String({
+      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
+    })
+  ),
+  cron: Type2.Optional(
+    Type2.String({
+      description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
+    })
+  ),
+  prompt: Type2.Optional(
+    Type2.String({
+      description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
+    })
+  ),
+  timezone: Type2.Optional(
+    Type2.String({
+      description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
+    })
+  )
 });
-var TypeGuardUnknownTypeError = class extends TypeBoxError {
-};
-var KnownTypes = [
-  "Argument",
-  "Any",
-  "Array",
-  "AsyncIterator",
-  "BigInt",
-  "Boolean",
-  "Computed",
-  "Constructor",
-  "Date",
-  "Enum",
-  "Function",
-  "Integer",
-  "Intersect",
-  "Iterator",
-  "Literal",
-  "MappedKey",
-  "MappedResult",
-  "Not",
-  "Null",
-  "Number",
-  "Object",
-  "Promise",
-  "Record",
-  "Ref",
-  "RegExp",
-  "String",
-  "Symbol",
-  "TemplateLiteral",
-  "This",
-  "Tuple",
-  "Undefined",
-  "Union",
-  "Uint8Array",
-  "Unknown",
-  "Void"
-];
-function IsPattern(value) {
-  try {
-    new RegExp(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function IsControlCharacterFree(value) {
-  if (!IsString(value))
-    return false;
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
-      return false;
-    }
-  }
-  return true;
-}
-function IsAdditionalProperties(value) {
-  return IsOptionalBoolean(value) || IsSchema2(value);
-}
-function IsOptionalBigInt(value) {
-  return IsUndefined(value) || IsBigInt(value);
-}
-function IsOptionalNumber(value) {
-  return IsUndefined(value) || IsNumber(value);
-}
-function IsOptionalBoolean(value) {
-  return IsUndefined(value) || IsBoolean(value);
-}
-function IsOptionalString(value) {
-  return IsUndefined(value) || IsString(value);
-}
-function IsOptionalPattern(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
-}
-function IsOptionalFormat(value) {
-  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
-}
-function IsOptionalSchema(value) {
-  return IsUndefined(value) || IsSchema2(value);
-}
-function IsReadonly2(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional2(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
-}
-function IsAny2(value) {
-  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
-}
-function IsArgument2(value) {
-  return IsKindOf2(value, "Argument") && IsNumber(value.index);
-}
-function IsArray4(value) {
-  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
-}
-function IsAsyncIterator3(value) {
-  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
-}
-function IsBigInt3(value) {
-  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
-}
-function IsBoolean3(value) {
-  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
-}
-function IsComputed2(value) {
-  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
-}
-function IsConstructor2(value) {
-  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
-}
-function IsDate3(value) {
-  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
-}
-function IsFunction3(value) {
-  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
-}
-function IsImport(value) {
-  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
-}
-function IsInteger2(value) {
-  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
-}
-function IsProperties(value) {
-  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
-}
-function IsIntersect2(value) {
-  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
-}
-function IsIterator3(value) {
-  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
-}
-function IsKindOf2(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralString(value) {
-  return IsLiteral2(value) && IsString(value.const);
-}
-function IsLiteralNumber(value) {
-  return IsLiteral2(value) && IsNumber(value.const);
-}
-function IsLiteralBoolean(value) {
-  return IsLiteral2(value) && IsBoolean(value.const);
-}
-function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
-}
-function IsLiteralValue2(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
-}
-function IsMappedKey2(value) {
-  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
-}
-function IsMappedResult2(value) {
-  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
-}
-function IsNever2(value) {
-  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
-}
-function IsNot2(value) {
-  return IsKindOf2(value, "Not") && IsSchema2(value.not);
-}
-function IsNull3(value) {
-  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
-}
-function IsNumber4(value) {
-  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
-}
-function IsObject4(value) {
-  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
-}
-function IsPromise2(value) {
-  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
-}
-function IsRecord2(value) {
-  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
-    const keys = Object.getOwnPropertyNames(schema.patternProperties);
-    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
-  })(value);
-}
-function IsRecursive(value) {
-  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
-}
-function IsRef2(value) {
-  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
-}
-function IsRegExp3(value) {
-  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
-}
-function IsString3(value) {
-  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
-}
-function IsSymbol3(value) {
-  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
-}
-function IsTemplateLiteral2(value) {
-  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
-}
-function IsThis2(value) {
-  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
-}
-function IsTransform2(value) {
-  return IsObject(value) && TransformKind in value;
-}
-function IsTuple2(value) {
-  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
-  (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
-}
-function IsUndefined4(value) {
-  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
-}
-function IsUnionLiteral(value) {
-  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
-}
-function IsUnion2(value) {
-  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
-}
-function IsUint8Array3(value) {
-  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
-}
-function IsUnknown2(value) {
-  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
-}
-function IsUnsafe2(value) {
-  return IsKindOf2(value, "Unsafe");
-}
-function IsVoid2(value) {
-  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
-}
-function IsKind2(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
-}
-function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
-var PatternBoolean = "(true|false)";
-var PatternNumber = "(0|[1-9][0-9]*)";
-var PatternString = "(.*)";
-var PatternNever = "(?!.*)";
-var PatternBooleanExact = `^${PatternBoolean}$`;
-var PatternNumberExact = `^${PatternNumber}$`;
-var PatternStringExact = `^${PatternString}$`;
-var PatternNeverExact = `^${PatternNever}$`;
-
-// node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
-function SetIncludes(T, S) {
-  return T.includes(S);
-}
-function SetDistinct(T) {
-  return [...new Set(T)];
-}
-function SetIntersect(T, S) {
-  return T.filter((L) => S.includes(L));
-}
-function SetIntersectManyResolve(T, Init) {
-  return T.reduce((Acc, L) => {
-    return SetIntersect(Acc, L);
-  }, Init);
-}
-function SetIntersectMany(T) {
-  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
-}
-function SetUnionMany(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...L);
-  return Acc;
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
-function Any(options) {
-  return CreateType({ [Kind]: "Any" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
-function Array2(items, options) {
-  return CreateType({ [Kind]: "Array", type: "array", items }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
-function Argument(index) {
-  return CreateType({ [Kind]: "Argument", index });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
-function AsyncIterator(items, options) {
-  return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
-function Computed(target, parameters, options) {
-  return CreateType({ [Kind]: "Computed", target, parameters }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
-function DiscardKey(value, key) {
-  const { [key]: _, ...rest } = value;
-  return rest;
-}
-function Discard(value, keys) {
-  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
-function Never(options) {
-  return CreateType({ [Kind]: "Never", not: {} }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
-function MappedResult(properties) {
-  return CreateType({
-    [Kind]: "MappedResult",
-    properties
-  });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
-function Constructor(parameters, returns, options) {
-  return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
-function Function(parameters, returns, options) {
-  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
-function UnionCreate(T, options) {
-  return CreateType({ [Kind]: "Union", anyOf: T }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
-function IsUnionOptional(types) {
-  return types.some((type) => IsOptional(type));
-}
-function RemoveOptionalFromRest(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
-}
-function RemoveOptionalFromType(T) {
-  return Discard(T, [OptionalKind]);
-}
-function ResolveUnion(types, options) {
-  const isOptional = IsUnionOptional(types);
-  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
-}
-function UnionEvaluated(T, options) {
-  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
-function Union(types, options) {
-  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
-var TemplateLiteralParserError = class extends TypeBoxError {
-};
-function Unescape(pattern) {
-  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
-}
-function IsNonEscaped(pattern, index, char) {
-  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
-}
-function IsOpenParen(pattern, index) {
-  return IsNonEscaped(pattern, index, "(");
-}
-function IsCloseParen(pattern, index) {
-  return IsNonEscaped(pattern, index, ")");
-}
-function IsSeparator(pattern, index) {
-  return IsNonEscaped(pattern, index, "|");
-}
-function IsGroup(pattern) {
-  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
-    return false;
-  let count = 0;
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (count === 0 && index !== pattern.length - 1)
-      return false;
-  }
-  return true;
-}
-function InGroup(pattern) {
-  return pattern.slice(1, pattern.length - 1);
-}
-function IsPrecedenceOr(pattern) {
-  let count = 0;
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0)
-      return true;
-  }
-  return false;
-}
-function IsPrecedenceAnd(pattern) {
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      return true;
-  }
-  return false;
-}
-function Or(pattern) {
-  let [count, start] = [0, 0];
-  const expressions = [];
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index))
-      count += 1;
-    if (IsCloseParen(pattern, index))
-      count -= 1;
-    if (IsSeparator(pattern, index) && count === 0) {
-      const range2 = pattern.slice(start, index);
-      if (range2.length > 0)
-        expressions.push(TemplateLiteralParse(range2));
-      start = index + 1;
-    }
-  }
-  const range = pattern.slice(start);
-  if (range.length > 0)
-    expressions.push(TemplateLiteralParse(range));
-  if (expressions.length === 0)
-    return { type: "const", const: "" };
-  if (expressions.length === 1)
-    return expressions[0];
-  return { type: "or", expr: expressions };
-}
-function And(pattern) {
-  function Group(value, index) {
-    if (!IsOpenParen(value, index))
-      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-    let count = 0;
-    for (let scan = index; scan < value.length; scan++) {
-      if (IsOpenParen(value, scan))
-        count += 1;
-      if (IsCloseParen(value, scan))
-        count -= 1;
-      if (count === 0)
-        return [index, scan];
-    }
-    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
-  }
-  function Range(pattern2, index) {
-    for (let scan = index; scan < pattern2.length; scan++) {
-      if (IsOpenParen(pattern2, scan))
-        return [index, scan];
-    }
-    return [index, pattern2.length];
-  }
-  const expressions = [];
-  for (let index = 0; index < pattern.length; index++) {
-    if (IsOpenParen(pattern, index)) {
-      const [start, end] = Group(pattern, index);
-      const range = pattern.slice(start, end + 1);
-      expressions.push(TemplateLiteralParse(range));
-      index = end;
-    } else {
-      const [start, end] = Range(pattern, index);
-      const range = pattern.slice(start, end);
-      if (range.length > 0)
-        expressions.push(TemplateLiteralParse(range));
-      index = end - 1;
-    }
-  }
-  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
-}
-function TemplateLiteralParse(pattern) {
-  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
-}
-function TemplateLiteralParseExact(pattern) {
-  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
-var TemplateLiteralFiniteError = class extends TypeBoxError {
-};
-function IsNumberExpression(expression) {
-  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
-}
-function IsBooleanExpression(expression) {
-  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
-}
-function IsStringExpression(expression) {
-  return expression.type === "const" && expression.const === ".*";
-}
-function IsTemplateLiteralExpressionFinite(expression) {
-  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
-    throw new TemplateLiteralFiniteError(`Unknown expression type`);
-  })();
-}
-function IsTemplateLiteralFinite(schema) {
-  const expression = TemplateLiteralParseExact(schema.pattern);
-  return IsTemplateLiteralExpressionFinite(expression);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
-var TemplateLiteralGenerateError = class extends TypeBoxError {
-};
-function* GenerateReduce(buffer) {
-  if (buffer.length === 1)
-    return yield* buffer[0];
-  for (const left of buffer[0]) {
-    for (const right of GenerateReduce(buffer.slice(1))) {
-      yield `${left}${right}`;
-    }
-  }
-}
-function* GenerateAnd(expression) {
-  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
-}
-function* GenerateOr(expression) {
-  for (const expr of expression.expr)
-    yield* TemplateLiteralExpressionGenerate(expr);
-}
-function* GenerateConst(expression) {
-  return yield expression.const;
-}
-function* TemplateLiteralExpressionGenerate(expression) {
-  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
-    throw new TemplateLiteralGenerateError("Unknown expression");
-  })();
-}
-function TemplateLiteralGenerate(schema) {
-  const expression = TemplateLiteralParseExact(schema.pattern);
-  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
-function Literal(value, options) {
-  return CreateType({
-    [Kind]: "Literal",
-    const: value,
-    type: typeof value
-  }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
-function Boolean2(options) {
-  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
-function BigInt(options) {
-  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
-function Number2(options) {
-  return CreateType({ [Kind]: "Number", type: "number" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
-function String2(options) {
-  return CreateType({ [Kind]: "String", type: "string" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
-function* FromUnion(syntax) {
-  const trim = syntax.trim().replace(/"|'/g, "");
-  return trim === "boolean" ? yield Boolean2() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
-    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
-    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
-  })();
-}
-function* FromTerminal(syntax) {
-  if (syntax[1] !== "{") {
-    const L = Literal("$");
-    const R = FromSyntax(syntax.slice(1));
-    return yield* [L, ...R];
-  }
-  for (let i = 2; i < syntax.length; i++) {
-    if (syntax[i] === "}") {
-      const L = FromUnion(syntax.slice(2, i));
-      const R = FromSyntax(syntax.slice(i + 1));
-      return yield* [...L, ...R];
-    }
-  }
-  yield Literal(syntax);
-}
-function* FromSyntax(syntax) {
-  for (let i = 0; i < syntax.length; i++) {
-    if (syntax[i] === "$") {
-      const L = Literal(syntax.slice(0, i));
-      const R = FromTerminal(syntax.slice(i));
-      return yield* [L, ...R];
-    }
-  }
-  yield Literal(syntax);
-}
-function TemplateLiteralSyntax(syntax) {
-  return [...FromSyntax(syntax)];
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
-var TemplateLiteralPatternError = class extends TypeBoxError {
-};
-function Escape(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function Visit2(schema, acc) {
-  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
-    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
-  })();
-}
-function TemplateLiteralPattern(kinds) {
-  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
-function TemplateLiteralToUnion(schema) {
-  const R = TemplateLiteralGenerate(schema);
-  const L = R.map((S) => Literal(S));
-  return UnionEvaluated(L);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
-function TemplateLiteral(unresolved, options) {
-  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
-  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
-function FromTemplateLiteral(templateLiteral) {
-  const keys = TemplateLiteralGenerate(templateLiteral);
-  return keys.map((key) => key.toString());
-}
-function FromUnion2(types) {
-  const result = [];
-  for (const type of types)
-    result.push(...IndexPropertyKeys(type));
-  return result;
-}
-function FromLiteral(literalValue) {
-  return [literalValue.toString()];
-}
-function IndexPropertyKeys(type) {
-  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
-function FromProperties(type, properties, options) {
-  const result = {};
-  for (const K2 of Object.getOwnPropertyNames(properties)) {
-    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
-  }
-  return result;
-}
-function FromMappedResult(type, mappedResult, options) {
-  return FromProperties(type, mappedResult.properties, options);
-}
-function IndexFromMappedResult(type, mappedResult, options) {
-  const properties = FromMappedResult(type, mappedResult, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
-function FromRest(types, key) {
-  return types.map((type) => IndexFromPropertyKey(type, key));
-}
-function FromIntersectRest(types) {
-  return types.filter((type) => !IsNever(type));
-}
-function FromIntersect(types, key) {
-  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
-}
-function FromUnionRest(types) {
-  return types.some((L) => IsNever(L)) ? [] : types;
-}
-function FromUnion3(types, key) {
-  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
-}
-function FromTuple(types, key) {
-  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
-}
-function FromArray(type, key) {
-  return key === "[number]" ? type : Never();
-}
-function FromProperty(properties, propertyKey) {
-  return propertyKey in properties ? properties[propertyKey] : Never();
-}
-function IndexFromPropertyKey(type, propertyKey) {
-  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
-}
-function IndexFromPropertyKeys(type, propertyKeys) {
-  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
-}
-function FromSchema(type, propertyKeys) {
-  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
-}
-function Index(type, key, options) {
-  if (IsRef(type) || IsRef(key)) {
-    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
-    if (!IsSchema(type) || !IsSchema(key))
-      throw new TypeBoxError(error);
-    return Computed("Index", [type, key]);
-  }
-  if (IsMappedResult(key))
-    return IndexFromMappedResult(type, key, options);
-  if (IsMappedKey(key))
-    return IndexFromMappedKey(type, key, options);
-  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
-function MappedIndexPropertyKey(type, key, options) {
-  return { [key]: Index(type, [key], Clone(options)) };
-}
-function MappedIndexPropertyKeys(type, propertyKeys, options) {
-  return propertyKeys.reduce((result, left) => {
-    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
-  }, {});
-}
-function MappedIndexProperties(type, mappedKey, options) {
-  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
-}
-function IndexFromMappedKey(type, mappedKey, options) {
-  const properties = MappedIndexProperties(type, mappedKey, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
-function Iterator(items, options) {
-  return CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
-function RequiredArray(properties) {
-  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
-}
-function _Object(properties, options) {
-  const required = RequiredArray(properties);
-  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
-  return CreateType(schema, options);
-}
-var Object2 = _Object;
-
-// node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
-function Promise2(item, options) {
-  return CreateType({ [Kind]: "Promise", type: "Promise", item }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
-function RemoveReadonly(schema) {
-  return CreateType(Discard(schema, [ReadonlyKind]));
-}
-function AddReadonly(schema) {
-  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
-}
-function ReadonlyWithFlag(schema, F) {
-  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
-}
-function Readonly(schema, enable) {
-  const F = enable ?? true;
-  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
-function FromProperties2(K, F) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-    Acc[K2] = Readonly(K[K2], F);
-  return Acc;
-}
-function FromMappedResult2(R, F) {
-  return FromProperties2(R.properties, F);
-}
-function ReadonlyFromMappedResult(R, F) {
-  const P = FromMappedResult2(R, F);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
-function Tuple(types, options) {
-  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
-function FromMappedResult3(K, P) {
-  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
-}
-function MappedKeyToKnownMappedResultProperties(K) {
-  return { [K]: Literal(K) };
-}
-function MappedKeyToUnknownMappedResultProperties(P) {
-  const Acc = {};
-  for (const L of P)
-    Acc[L] = Literal(L);
-  return Acc;
-}
-function MappedKeyToMappedResultProperties(K, P) {
-  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
-}
-function FromMappedKey(K, P) {
-  const R = MappedKeyToMappedResultProperties(K, P);
-  return FromMappedResult3(K, R);
-}
-function FromRest2(K, T) {
-  return T.map((L) => FromSchemaType(K, L));
-}
-function FromProperties3(K, T) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
-    Acc[K2] = FromSchemaType(K, T[K2]);
-  return Acc;
-}
-function FromSchemaType(K, T) {
-  const options = { ...T };
-  return (
-    // unevaluated modifier types
-    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
-      // unevaluated mapped types
-      IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
-        // unevaluated types
-        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction2(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf), options) : IsUnion(T) ? Union(FromRest2(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? []), options) : IsObject3(T) ? Object2(FromProperties3(K, T.properties), options) : IsArray3(T) ? Array2(FromSchemaType(K, T.items), options) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item), options) : T
-      )
-    )
-  );
-}
-function MappedFunctionReturnType(K, T) {
-  const Acc = {};
-  for (const L of K)
-    Acc[L] = FromSchemaType(L, T);
-  return Acc;
-}
-function Mapped(key, map, options) {
-  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const RT = map({ [Kind]: "MappedKey", keys: K });
-  const R = MappedFunctionReturnType(K, RT);
-  return Object2(R, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
-function RemoveOptional(schema) {
-  return CreateType(Discard(schema, [OptionalKind]));
-}
-function AddOptional(schema) {
-  return CreateType({ ...schema, [OptionalKind]: "Optional" });
-}
-function OptionalWithFlag(schema, F) {
-  return F === false ? RemoveOptional(schema) : AddOptional(schema);
-}
-function Optional(schema, enable) {
-  const F = enable ?? true;
-  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
-function FromProperties4(P, F) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Optional(P[K2], F);
-  return Acc;
-}
-function FromMappedResult4(R, F) {
-  return FromProperties4(R.properties, F);
-}
-function OptionalFromMappedResult(R, F) {
-  const P = FromMappedResult4(R, F);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
-function IntersectCreate(T, options = {}) {
-  const allObjects = T.every((schema) => IsObject3(schema));
-  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
-  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
-function IsIntersectOptional(types) {
-  return types.every((left) => IsOptional(left));
-}
-function RemoveOptionalFromType2(type) {
-  return Discard(type, [OptionalKind]);
-}
-function RemoveOptionalFromRest2(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
-}
-function ResolveIntersect(types, options) {
-  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
-}
-function IntersectEvaluated(types, options = {}) {
-  if (types.length === 1)
-    return CreateType(types[0], options);
-  if (types.length === 0)
-    return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
-    throw new Error("Cannot intersect transform types");
-  return ResolveIntersect(types, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
-function Intersect(types, options) {
-  if (types.length === 1)
-    return CreateType(types[0], options);
-  if (types.length === 0)
-    return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
-    throw new Error("Cannot intersect transform types");
-  return IntersectCreate(types, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
-function Ref(...args) {
-  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
-  if (typeof $ref !== "string")
-    throw new TypeBoxError("Ref: $ref must be a string");
-  return CreateType({ [Kind]: "Ref", $ref }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
-function FromComputed(target, parameters) {
-  return Computed("Awaited", [Computed(target, parameters)]);
-}
-function FromRef($ref) {
-  return Computed("Awaited", [Ref($ref)]);
-}
-function FromIntersect2(types) {
-  return Intersect(FromRest3(types));
-}
-function FromUnion4(types) {
-  return Union(FromRest3(types));
-}
-function FromPromise(type) {
-  return Awaited(type);
-}
-function FromRest3(types) {
-  return types.map((type) => Awaited(type));
-}
-function Awaited(type, options) {
-  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
-function FromRest4(types) {
-  const result = [];
-  for (const L of types)
-    result.push(KeyOfPropertyKeys(L));
-  return result;
-}
-function FromIntersect3(types) {
-  const propertyKeysArray = FromRest4(types);
-  const propertyKeys = SetUnionMany(propertyKeysArray);
-  return propertyKeys;
-}
-function FromUnion5(types) {
-  const propertyKeysArray = FromRest4(types);
-  const propertyKeys = SetIntersectMany(propertyKeysArray);
-  return propertyKeys;
-}
-function FromTuple2(types) {
-  return types.map((_, indexer) => indexer.toString());
-}
-function FromArray2(_) {
-  return ["[number]"];
-}
-function FromProperties5(T) {
-  return globalThis.Object.getOwnPropertyNames(T);
-}
-function FromPatternProperties(patternProperties) {
-  if (!includePatternProperties)
-    return [];
-  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
-  return patternPropertyKeys.map((key) => {
-    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
-  });
-}
-function KeyOfPropertyKeys(type) {
-  return IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion5(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
-}
-var includePatternProperties = false;
-
-// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
-function FromComputed2(target, parameters) {
-  return Computed("KeyOf", [Computed(target, parameters)]);
-}
-function FromRef2($ref) {
-  return Computed("KeyOf", [Ref($ref)]);
-}
-function KeyOfFromType(type, options) {
-  const propertyKeys = KeyOfPropertyKeys(type);
-  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
-  const result = UnionEvaluated(propertyKeyTypes);
-  return CreateType(result, options);
-}
-function KeyOfPropertyKeysToRest(propertyKeys) {
-  return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
-}
-function KeyOf(type, options) {
-  return IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsRef(type) ? FromRef2(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
-function FromProperties6(properties, options) {
-  const result = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
-    result[K2] = KeyOf(properties[K2], Clone(options));
-  return result;
-}
-function FromMappedResult5(mappedResult, options) {
-  return FromProperties6(mappedResult.properties, options);
-}
-function KeyOfFromMappedResult(mappedResult, options) {
-  const properties = FromMappedResult5(mappedResult, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
-function CompositeKeys(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...KeyOfPropertyKeys(L));
-  return SetDistinct(Acc);
-}
-function FilterNever(T) {
-  return T.filter((L) => !IsNever(L));
-}
-function CompositeProperty(T, K) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...IndexFromPropertyKeys(L, [K]));
-  return FilterNever(Acc);
-}
-function CompositeProperties(T, K) {
-  const Acc = {};
-  for (const L of K) {
-    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
-  }
-  return Acc;
-}
-function Composite(T, options) {
-  const K = CompositeKeys(T);
-  const P = CompositeProperties(T, K);
-  const R = Object2(P, options);
-  return R;
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
-function Date2(options) {
-  return CreateType({ [Kind]: "Date", type: "Date" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
-function Null(options) {
-  return CreateType({ [Kind]: "Null", type: "null" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
-function Symbol2(options) {
-  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
-function Undefined(options) {
-  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
-function Uint8Array2(options) {
-  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
-function Unknown(options) {
-  return CreateType({ [Kind]: "Unknown" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
-function FromArray3(T) {
-  return T.map((L) => FromValue(L, false));
-}
-function FromProperties7(value) {
-  const Acc = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(value))
-    Acc[K] = Readonly(FromValue(value[K], false));
-  return Acc;
-}
-function ConditionalReadonly(T, root) {
-  return root === true ? T : Readonly(T);
-}
-function FromValue(value, root) {
-  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
-}
-function Const(T, options) {
-  return CreateType(FromValue(T, true), options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
-function ConstructorParameters(schema, options) {
-  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
-function Enum(item, options) {
-  if (IsUndefined(item))
-    throw new Error("Enum undefined or empty");
-  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
-  const values2 = [...new Set(values1)];
-  const anyOf = values2.map((value) => Literal(value));
-  return Union(anyOf, { ...options, [Hint]: "Enum" });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
-var ExtendsResolverError = class extends TypeBoxError {
-};
-var ExtendsResult;
-(function(ExtendsResult2) {
-  ExtendsResult2[ExtendsResult2["Union"] = 0] = "Union";
-  ExtendsResult2[ExtendsResult2["True"] = 1] = "True";
-  ExtendsResult2[ExtendsResult2["False"] = 2] = "False";
-})(ExtendsResult || (ExtendsResult = {}));
-function IntoBooleanResult(result) {
-  return result === ExtendsResult.False ? result : ExtendsResult.True;
-}
-function Throw(message) {
-  throw new ExtendsResolverError(message);
-}
-function IsStructuralRight(right) {
-  return type_exports.IsNever(right) || type_exports.IsIntersect(right) || type_exports.IsUnion(right) || type_exports.IsUnknown(right) || type_exports.IsAny(right);
-}
-function StructuralRight(left, right) {
-  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
-}
-function FromAnyRight(left, right) {
-  return ExtendsResult.True;
-}
-function FromAny(left, right) {
-  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) && right.anyOf.some((schema) => type_exports.IsAny(schema) || type_exports.IsUnknown(schema)) ? ExtendsResult.True : type_exports.IsUnion(right) ? ExtendsResult.Union : type_exports.IsUnknown(right) ? ExtendsResult.True : type_exports.IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
-}
-function FromArrayRight(left, right) {
-  return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromArray4(left, right) {
-  return type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
-}
-function FromAsyncIterator(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
-}
-function FromBigInt(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromBooleanRight(left, right) {
-  return type_exports.IsLiteralBoolean(left) ? ExtendsResult.True : type_exports.IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromBoolean(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromConstructor(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
-}
-function FromDate(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromFunction(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
-}
-function FromIntegerRight(left, right) {
-  return type_exports.IsLiteral(left) && value_exports.IsNumber(left.const) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromInteger(left, right) {
-  return type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
-}
-function FromIntersectRight(left, right) {
-  return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromIntersect4(left, right) {
-  return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromIterator(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
-}
-function FromLiteral2(left, right) {
-  return type_exports.IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
-}
-function FromNeverRight(left, right) {
-  return ExtendsResult.False;
-}
-function FromNever(left, right) {
-  return ExtendsResult.True;
-}
-function UnwrapTNot(schema) {
-  let [current, depth] = [schema, 0];
-  while (true) {
-    if (!type_exports.IsNot(current))
-      break;
-    current = current.not;
-    depth += 1;
-  }
-  return depth % 2 === 0 ? current : Unknown();
-}
-function FromNot(left, right) {
-  return type_exports.IsNot(left) ? Visit3(UnwrapTNot(left), right) : type_exports.IsNot(right) ? Visit3(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
-}
-function FromNull(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromNumberRight(left, right) {
-  return type_exports.IsLiteralNumber(left) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromNumber(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function IsObjectPropertyCount(schema, count) {
-  return Object.getOwnPropertyNames(schema.properties).length === count;
-}
-function IsObjectStringLike(schema) {
-  return IsObjectArrayLike(schema);
-}
-function IsObjectSymbolLike(schema) {
-  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && type_exports.IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (type_exports.IsString(schema.properties.description.anyOf[0]) && type_exports.IsUndefined(schema.properties.description.anyOf[1]) || type_exports.IsString(schema.properties.description.anyOf[1]) && type_exports.IsUndefined(schema.properties.description.anyOf[0]));
-}
-function IsObjectNumberLike(schema) {
-  return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectBooleanLike(schema) {
-  return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectBigIntLike(schema) {
-  return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectDateLike(schema) {
-  return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectUint8ArrayLike(schema) {
-  return IsObjectArrayLike(schema);
-}
-function IsObjectFunctionLike(schema) {
-  const length = Number2();
-  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
-}
-function IsObjectConstructorLike(schema) {
-  return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectArrayLike(schema) {
-  const length = Number2();
-  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
-}
-function IsObjectPromiseLike(schema) {
-  const then = Function([Any()], Any());
-  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit3(schema.properties["then"], then)) === ExtendsResult.True;
-}
-function Property(left, right) {
-  return Visit3(left, right) === ExtendsResult.False ? ExtendsResult.False : type_exports.IsOptional(left) && !type_exports.IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
-}
-function FromObjectRight(left, right) {
-  return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) || type_exports.IsLiteralString(left) && IsObjectStringLike(right) || type_exports.IsLiteralNumber(left) && IsObjectNumberLike(right) || type_exports.IsLiteralBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsBigInt(left) && IsObjectBigIntLike(right) || type_exports.IsString(left) && IsObjectStringLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsNumber(left) && IsObjectNumberLike(right) || type_exports.IsInteger(left) && IsObjectNumberLike(right) || type_exports.IsBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsUint8Array(left) && IsObjectUint8ArrayLike(right) || type_exports.IsDate(left) && IsObjectDateLike(right) || type_exports.IsConstructor(left) && IsObjectConstructorLike(right) || type_exports.IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : type_exports.IsRecord(left) && type_exports.IsString(RecordKey(left)) ? (() => {
-    return right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False;
-  })() : type_exports.IsRecord(left) && type_exports.IsNumber(RecordKey(left)) ? (() => {
-    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
-  })() : ExtendsResult.False;
-}
-function FromObject(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : !type_exports.IsObject(right) ? ExtendsResult.False : (() => {
-    for (const key of Object.getOwnPropertyNames(right.properties)) {
-      if (!(key in left.properties) && !type_exports.IsOptional(right.properties[key])) {
-        return ExtendsResult.False;
-      }
-      if (type_exports.IsOptional(right.properties[key])) {
-        return ExtendsResult.True;
-      }
-      if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
-        return ExtendsResult.False;
-      }
-    }
-    return ExtendsResult.True;
-  })();
-}
-function FromPromise2(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !type_exports.IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.item, right.item));
-}
-function RecordKey(schema) {
-  return PatternNumberExact in schema.patternProperties ? Number2() : PatternStringExact in schema.patternProperties ? String2() : Throw("Unknown record key pattern");
-}
-function RecordValue(schema) {
-  return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
-}
-function FromRecordRight(left, right) {
-  const [Key, Value] = [RecordKey(right), RecordValue(right)];
-  return type_exports.IsLiteralString(left) && type_exports.IsNumber(Key) && IntoBooleanResult(Visit3(left, Value)) === ExtendsResult.True ? ExtendsResult.True : type_exports.IsUint8Array(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsString(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsArray(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsObject(left) ? (() => {
-    for (const key of Object.getOwnPropertyNames(left.properties)) {
-      if (Property(Value, left.properties[key]) === ExtendsResult.False) {
-        return ExtendsResult.False;
-      }
-    }
-    return ExtendsResult.True;
-  })() : ExtendsResult.False;
-}
-function FromRecord(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsRecord(right) ? ExtendsResult.False : Visit3(RecordValue(left), RecordValue(right));
-}
-function FromRegExp(left, right) {
-  const L = type_exports.IsRegExp(left) ? String2() : left;
-  const R = type_exports.IsRegExp(right) ? String2() : right;
-  return Visit3(L, R);
-}
-function FromStringRight(left, right) {
-  return type_exports.IsLiteral(left) && value_exports.IsString(left.const) ? ExtendsResult.True : type_exports.IsString(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromString(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromSymbol(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromTemplateLiteral2(left, right) {
-  return type_exports.IsTemplateLiteral(left) ? Visit3(TemplateLiteralToUnion(left), right) : type_exports.IsTemplateLiteral(right) ? Visit3(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
-}
-function IsArrayOfTuple(left, right) {
-  return type_exports.IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit3(schema, right.items) === ExtendsResult.True);
-}
-function FromTupleRight(left, right) {
-  return type_exports.IsNever(left) ? ExtendsResult.True : type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
-}
-function FromTuple3(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : type_exports.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !type_exports.IsTuple(right) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) || !value_exports.IsUndefined(left.items) && value_exports.IsUndefined(right.items) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit3(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUint8Array(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUndefined(left, right) {
-  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsVoid(right) ? FromVoidRight(left, right) : type_exports.IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnionRight(left, right) {
-  return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnion6(left, right) {
-  return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnknownRight(left, right) {
-  return ExtendsResult.True;
-}
-function FromUnknown(left, right) {
-  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : type_exports.IsArray(right) ? FromArrayRight(left, right) : type_exports.IsTuple(right) ? FromTupleRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromVoidRight(left, right) {
-  return type_exports.IsUndefined(left) ? ExtendsResult.True : type_exports.IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromVoid(left, right) {
-  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function Visit3(left, right) {
-  return (
-    // resolvable
-    type_exports.IsTemplateLiteral(left) || type_exports.IsTemplateLiteral(right) ? FromTemplateLiteral2(left, right) : type_exports.IsRegExp(left) || type_exports.IsRegExp(right) ? FromRegExp(left, right) : type_exports.IsNot(left) || type_exports.IsNot(right) ? FromNot(left, right) : (
-      // standard
-      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray4(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator(left, right) : type_exports.IsConstructor(left) ? FromConstructor(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect4(left, right) : type_exports.IsIterator(left) ? FromIterator(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple3(left, right) : type_exports.IsPromise(left) ? FromPromise2(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion6(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
-    )
-  );
-}
-function ExtendsCheck(left, right) {
-  return Visit3(left, right);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
-function FromProperties8(P, Right, True, False, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
-  return Acc;
-}
-function FromMappedResult6(Left, Right, True, False, options) {
-  return FromProperties8(Left.properties, Right, True, False, options);
-}
-function ExtendsFromMappedResult(Left, Right, True, False, options) {
-  const P = FromMappedResult6(Left, Right, True, False, options);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs
-function ExtendsResolve(left, right, trueType, falseType) {
-  const R = ExtendsCheck(left, right);
-  return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
-}
-function Extends(L, R, T, F, options) {
-  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
-function FromPropertyKey(K, U, L, R, options) {
-  return {
-    [K]: Extends(Literal(K), U, L, R, Clone(options))
-  };
-}
-function FromPropertyKeys(K, U, L, R, options) {
-  return K.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
-  }, {});
-}
-function FromMappedKey2(K, U, L, R, options) {
-  return FromPropertyKeys(K.keys, U, L, R, options);
-}
-function ExtendsFromMappedKey(T, U, L, R, options) {
-  const P = FromMappedKey2(T, U, L, R, options);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs
-function ExcludeFromTemplateLiteral(L, R) {
-  return Exclude(TemplateLiteralToUnion(L), R);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
-function ExcludeRest(L, R) {
-  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
-  return excluded.length === 1 ? excluded[0] : Union(excluded);
-}
-function Exclude(L, R, options = {}) {
-  if (IsTemplateLiteral(L))
-    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
-    return CreateType(ExcludeFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
-function FromProperties9(P, U) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Exclude(P[K2], U);
-  return Acc;
-}
-function FromMappedResult7(R, T) {
-  return FromProperties9(R.properties, T);
-}
-function ExcludeFromMappedResult(R, T) {
-  const P = FromMappedResult7(R, T);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
-function ExtractFromTemplateLiteral(L, R) {
-  return Extract(TemplateLiteralToUnion(L), R);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
-function ExtractRest(L, R) {
-  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-  return extracted.length === 1 ? extracted[0] : Union(extracted);
-}
-function Extract(L, R, options) {
-  if (IsTemplateLiteral(L))
-    return CreateType(ExtractFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
-    return CreateType(ExtractFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
-function FromProperties10(P, T) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Extract(P[K2], T);
-  return Acc;
-}
-function FromMappedResult8(R, T) {
-  return FromProperties10(R.properties, T);
-}
-function ExtractFromMappedResult(R, T) {
-  const P = FromMappedResult8(R, T);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
-function InstanceType(schema, options) {
-  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
-function ReadonlyOptional(schema) {
-  return Readonly(Optional(schema));
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
-function RecordCreateFromPattern(pattern, T, options) {
-  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
-}
-function RecordCreateFromKeys(K, T, options) {
-  const result = {};
-  for (const K2 of K)
-    result[K2] = T;
-  return Object2(result, { ...options, [Hint]: "Record" });
-}
-function FromTemplateLiteralKey(K, T, options) {
-  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
-}
-function FromUnionKey(key, type, options) {
-  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
-}
-function FromLiteralKey(key, type, options) {
-  return RecordCreateFromKeys([key.toString()], type, options);
-}
-function FromRegExpKey(key, type, options) {
-  return RecordCreateFromPattern(key.source, type, options);
-}
-function FromStringKey(key, type, options) {
-  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
-  return RecordCreateFromPattern(pattern, type, options);
-}
-function FromAnyKey(_, type, options) {
-  return RecordCreateFromPattern(PatternStringExact, type, options);
-}
-function FromNeverKey(_key, type, options) {
-  return RecordCreateFromPattern(PatternNeverExact, type, options);
-}
-function FromBooleanKey(_key, type, options) {
-  return Object2({ true: type, false: type }, options);
-}
-function FromIntegerKey(_key, type, options) {
-  return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function FromNumberKey(_, type, options) {
-  return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function Record(key, type, options = {}) {
-  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean2(key) ? FromBooleanKey(key, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
-}
-function RecordPattern(record) {
-  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
-}
-function RecordKey2(type) {
-  const pattern = RecordPattern(type);
-  return pattern === PatternStringExact ? String2() : pattern === PatternNumberExact ? Number2() : String2({ pattern });
-}
-function RecordValue2(type) {
-  return type.patternProperties[RecordPattern(type)];
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
-function FromConstructor2(args, type) {
-  type.parameters = FromTypes(args, type.parameters);
-  type.returns = FromType(args, type.returns);
-  return type;
-}
-function FromFunction2(args, type) {
-  type.parameters = FromTypes(args, type.parameters);
-  type.returns = FromType(args, type.returns);
-  return type;
-}
-function FromIntersect5(args, type) {
-  type.allOf = FromTypes(args, type.allOf);
-  return type;
-}
-function FromUnion7(args, type) {
-  type.anyOf = FromTypes(args, type.anyOf);
-  return type;
-}
-function FromTuple4(args, type) {
-  if (IsUndefined(type.items))
-    return type;
-  type.items = FromTypes(args, type.items);
-  return type;
-}
-function FromArray5(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
-}
-function FromAsyncIterator2(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
-}
-function FromIterator2(args, type) {
-  type.items = FromType(args, type.items);
-  return type;
-}
-function FromPromise3(args, type) {
-  type.item = FromType(args, type.item);
-  return type;
-}
-function FromObject2(args, type) {
-  const mappedProperties = FromProperties11(args, type.properties);
-  return { ...type, ...Object2(mappedProperties) };
-}
-function FromRecord2(args, type) {
-  const mappedKey = FromType(args, RecordKey2(type));
-  const mappedValue = FromType(args, RecordValue2(type));
-  const result = Record(mappedKey, mappedValue);
-  return { ...type, ...result };
-}
-function FromArgument(args, argument) {
-  return argument.index in args ? args[argument.index] : Unknown();
-}
-function FromProperty2(args, type) {
-  const isReadonly = IsReadonly(type);
-  const isOptional = IsOptional(type);
-  const mapped = FromType(args, type);
-  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
-}
-function FromProperties11(args, properties) {
-  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-    return { ...result, [key]: FromProperty2(args, properties[key]) };
-  }, {});
-}
-function FromTypes(args, types) {
-  return types.map((type) => FromType(args, type));
-}
-function FromType(args, type) {
-  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
-}
-function Instantiate(type, args) {
-  return FromType(args, CloneType(type));
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
-function Integer(options) {
-  return CreateType({ [Kind]: "Integer", type: "integer" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
-function MappedIntrinsicPropertyKey(K, M, options) {
-  return {
-    [K]: Intrinsic(Literal(K), M, Clone(options))
-  };
-}
-function MappedIntrinsicPropertyKeys(K, M, options) {
-  const result = K.reduce((Acc, L) => {
-    return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
-  }, {});
-  return result;
-}
-function MappedIntrinsicProperties(T, M, options) {
-  return MappedIntrinsicPropertyKeys(T["keys"], M, options);
-}
-function IntrinsicFromMappedKey(T, M, options) {
-  const P = MappedIntrinsicProperties(T, M, options);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
-function ApplyUncapitalize(value) {
-  const [first, rest] = [value.slice(0, 1), value.slice(1)];
-  return [first.toLowerCase(), rest].join("");
-}
-function ApplyCapitalize(value) {
-  const [first, rest] = [value.slice(0, 1), value.slice(1)];
-  return [first.toUpperCase(), rest].join("");
-}
-function ApplyUppercase(value) {
-  return value.toUpperCase();
-}
-function ApplyLowercase(value) {
-  return value.toLowerCase();
-}
-function FromTemplateLiteral3(schema, mode, options) {
-  const expression = TemplateLiteralParseExact(schema.pattern);
-  const finite = IsTemplateLiteralExpressionFinite(expression);
-  if (!finite)
-    return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-  const strings = [...TemplateLiteralExpressionGenerate(expression)];
-  const literals = strings.map((value) => Literal(value));
-  const mapped = FromRest5(literals, mode);
-  const union = Union(mapped);
-  return TemplateLiteral([union], options);
-}
-function FromLiteralValue(value, mode) {
-  return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
-}
-function FromRest5(T, M) {
-  return T.map((L) => Intrinsic(L, M));
-}
-function Intrinsic(schema, mode, options = {}) {
-  return (
-    // Intrinsic-Mapped-Inference
-    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
-      // Standard-Inference
-      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : (
-        // Default Type
-        CreateType(schema, options)
-      )
-    )
-  );
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
-function Capitalize(T, options = {}) {
-  return Intrinsic(T, "Capitalize", options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
-function Lowercase(T, options = {}) {
-  return Intrinsic(T, "Lowercase", options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
-function Uncapitalize(T, options = {}) {
-  return Intrinsic(T, "Uncapitalize", options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
-function Uppercase(T, options = {}) {
-  return Intrinsic(T, "Uppercase", options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
-function FromProperties12(properties, propertyKeys, options) {
-  const result = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
-    result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
-  return result;
-}
-function FromMappedResult9(mappedResult, propertyKeys, options) {
-  return FromProperties12(mappedResult.properties, propertyKeys, options);
-}
-function OmitFromMappedResult(mappedResult, propertyKeys, options) {
-  const properties = FromMappedResult9(mappedResult, propertyKeys, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
-function FromIntersect6(types, propertyKeys) {
-  return types.map((type) => OmitResolve(type, propertyKeys));
-}
-function FromUnion8(types, propertyKeys) {
-  return types.map((type) => OmitResolve(type, propertyKeys));
-}
-function FromProperty3(properties, key) {
-  const { [key]: _, ...R } = properties;
-  return R;
-}
-function FromProperties13(properties, propertyKeys) {
-  return propertyKeys.reduce((T, K2) => FromProperty3(T, K2), properties);
-}
-function FromObject3(type, propertyKeys, properties) {
-  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties13(properties, propertyKeys);
-  return Object2(mappedProperties, options);
-}
-function UnionFromPropertyKeys(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
-  return Union(result);
-}
-function OmitResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
-}
-function Omit(type, key, options) {
-  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
-  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef(type);
-  const isKeyRef = IsRef(key);
-  return IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({ ...OmitResolve(type, propertyKeys), ...options });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
-function FromPropertyKey2(type, key, options) {
-  return { [key]: Omit(type, [key], Clone(options)) };
-}
-function FromPropertyKeys2(type, propertyKeys, options) {
-  return propertyKeys.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey2(type, LK, options) };
-  }, {});
-}
-function FromMappedKey3(type, mappedKey, options) {
-  return FromPropertyKeys2(type, mappedKey.keys, options);
-}
-function OmitFromMappedKey(type, mappedKey, options) {
-  const properties = FromMappedKey3(type, mappedKey, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
-function FromProperties14(properties, propertyKeys, options) {
-  const result = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
-    result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
-  return result;
-}
-function FromMappedResult10(mappedResult, propertyKeys, options) {
-  return FromProperties14(mappedResult.properties, propertyKeys, options);
-}
-function PickFromMappedResult(mappedResult, propertyKeys, options) {
-  const properties = FromMappedResult10(mappedResult, propertyKeys, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
-function FromIntersect7(types, propertyKeys) {
-  return types.map((type) => PickResolve(type, propertyKeys));
-}
-function FromUnion9(types, propertyKeys) {
-  return types.map((type) => PickResolve(type, propertyKeys));
-}
-function FromProperties15(properties, propertyKeys) {
-  const result = {};
-  for (const K2 of propertyKeys)
-    if (K2 in properties)
-      result[K2] = properties[K2];
-  return result;
-}
-function FromObject4(Type2, keys, properties) {
-  const options = Discard(Type2, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties15(properties, keys);
-  return Object2(mappedProperties, options);
-}
-function UnionFromPropertyKeys2(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
-  return Union(result);
-}
-function PickResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
-}
-function Pick(type, key, options) {
-  const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
-  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef(type);
-  const isKeyRef = IsRef(key);
-  return IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({ ...PickResolve(type, propertyKeys), ...options });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
-function FromPropertyKey3(type, key, options) {
-  return {
-    [key]: Pick(type, [key], Clone(options))
-  };
-}
-function FromPropertyKeys3(type, propertyKeys, options) {
-  return propertyKeys.reduce((result, leftKey) => {
-    return { ...result, ...FromPropertyKey3(type, leftKey, options) };
-  }, {});
-}
-function FromMappedKey4(type, mappedKey, options) {
-  return FromPropertyKeys3(type, mappedKey.keys, options);
-}
-function PickFromMappedKey(type, mappedKey, options) {
-  const properties = FromMappedKey4(type, mappedKey, options);
-  return MappedResult(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
-function FromComputed3(target, parameters) {
-  return Computed("Partial", [Computed(target, parameters)]);
-}
-function FromRef3($ref) {
-  return Computed("Partial", [Ref($ref)]);
-}
-function FromProperties16(properties) {
-  const partialProperties = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(properties))
-    partialProperties[K] = Optional(properties[K]);
-  return partialProperties;
-}
-function FromObject5(type, properties) {
-  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties16(properties);
-  return Object2(mappedProperties, options);
-}
-function FromRest6(types) {
-  return types.map((type) => PartialResolve(type));
-}
-function PartialResolve(type) {
-  return (
-    // Mappable
-    IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject5(type, type.properties) : (
-      // Intrinsic
-      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
-        // Passthrough
-        Object2({})
-      )
-    )
-  );
-}
-function Partial(type, options) {
-  if (IsMappedResult(type)) {
-    return PartialFromMappedResult(type, options);
-  } else {
-    return CreateType({ ...PartialResolve(type), ...options });
-  }
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
-function FromProperties17(K, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-    Acc[K2] = Partial(K[K2], Clone(options));
-  return Acc;
-}
-function FromMappedResult11(R, options) {
-  return FromProperties17(R.properties, options);
-}
-function PartialFromMappedResult(R, options) {
-  const P = FromMappedResult11(R, options);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
-function FromComputed4(target, parameters) {
-  return Computed("Required", [Computed(target, parameters)]);
-}
-function FromRef4($ref) {
-  return Computed("Required", [Ref($ref)]);
-}
-function FromProperties18(properties) {
-  const requiredProperties = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(properties))
-    requiredProperties[K] = Discard(properties[K], [OptionalKind]);
-  return requiredProperties;
-}
-function FromObject6(type, properties) {
-  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const mappedProperties = FromProperties18(properties);
-  return Object2(mappedProperties, options);
-}
-function FromRest7(types) {
-  return types.map((type) => RequiredResolve(type));
-}
-function RequiredResolve(type) {
-  return (
-    // Mappable
-    IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject6(type, type.properties) : (
-      // Intrinsic
-      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
-        // Passthrough
-        Object2({})
-      )
-    )
-  );
-}
-function Required(type, options) {
-  if (IsMappedResult(type)) {
-    return RequiredFromMappedResult(type, options);
-  } else {
-    return CreateType({ ...RequiredResolve(type), ...options });
-  }
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
-function FromProperties19(P, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Required(P[K2], options);
-  return Acc;
-}
-function FromMappedResult12(R, options) {
-  return FromProperties19(R.properties, options);
-}
-function RequiredFromMappedResult(R, options) {
-  const P = FromMappedResult12(R, options);
-  return MappedResult(P);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
-function DereferenceParameters(moduleProperties, types) {
-  return types.map((type) => {
-    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
-  });
-}
-function Dereference(moduleProperties, ref) {
-  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
-}
-function FromAwaited(parameters) {
-  return Awaited(parameters[0]);
-}
-function FromIndex(parameters) {
-  return Index(parameters[0], parameters[1]);
-}
-function FromKeyOf(parameters) {
-  return KeyOf(parameters[0]);
-}
-function FromPartial(parameters) {
-  return Partial(parameters[0]);
-}
-function FromOmit(parameters) {
-  return Omit(parameters[0], parameters[1]);
-}
-function FromPick(parameters) {
-  return Pick(parameters[0], parameters[1]);
-}
-function FromRequired(parameters) {
-  return Required(parameters[0]);
-}
-function FromComputed5(moduleProperties, target, parameters) {
-  const dereferenced = DereferenceParameters(moduleProperties, parameters);
-  return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
-}
-function FromArray6(moduleProperties, type) {
-  return Array2(FromType2(moduleProperties, type));
-}
-function FromAsyncIterator3(moduleProperties, type) {
-  return AsyncIterator(FromType2(moduleProperties, type));
-}
-function FromConstructor3(moduleProperties, parameters, instanceType) {
-  return Constructor(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, instanceType));
-}
-function FromFunction3(moduleProperties, parameters, returnType) {
-  return Function(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, returnType));
-}
-function FromIntersect8(moduleProperties, types) {
-  return Intersect(FromTypes2(moduleProperties, types));
-}
-function FromIterator3(moduleProperties, type) {
-  return Iterator(FromType2(moduleProperties, type));
-}
-function FromObject7(moduleProperties, properties) {
-  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
-    return { ...result, [key]: FromType2(moduleProperties, properties[key]) };
-  }, {}));
-}
-function FromRecord3(moduleProperties, type) {
-  const [value, pattern] = [FromType2(moduleProperties, RecordValue2(type)), RecordPattern(type)];
-  const result = CloneType(type);
-  result.patternProperties[pattern] = value;
-  return result;
-}
-function FromTransform(moduleProperties, transform) {
-  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
-}
-function FromTuple5(moduleProperties, types) {
-  return Tuple(FromTypes2(moduleProperties, types));
-}
-function FromUnion10(moduleProperties, types) {
-  return Union(FromTypes2(moduleProperties, types));
-}
-function FromTypes2(moduleProperties, types) {
-  return types.map((type) => FromType2(moduleProperties, type));
-}
-function FromType2(moduleProperties, type) {
-  return (
-    // Modifiers
-    IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
-      // Transform
-      IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : (
-        // Types
-        IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type
-      )
-    )
-  );
-}
-function ComputeType(moduleProperties, key) {
-  return key in moduleProperties ? FromType2(moduleProperties, moduleProperties[key]) : Never();
-}
-function ComputeModuleProperties(moduleProperties) {
-  return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
-    return { ...result, [key]: ComputeType(moduleProperties, key) };
-  }, {});
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/module/module.mjs
-var TModule = class {
-  constructor($defs) {
-    const computed = ComputeModuleProperties($defs);
-    const identified = this.WithIdentifiers(computed);
-    this.$defs = identified;
-  }
-  /** `[Json]` Imports a Type by Key. */
-  Import(key, options) {
-    const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) };
-    return CreateType({ [Kind]: "Import", $defs, $ref: key });
-  }
-  // prettier-ignore
-  WithIdentifiers($defs) {
-    return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
-      return { ...result, [key]: { ...$defs[key], $id: key } };
-    }, {});
-  }
-};
-function Module(properties) {
-  return new TModule(properties);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
-function Not(type, options) {
-  return CreateType({ [Kind]: "Not", not: type }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
-function Parameters(schema, options) {
-  return IsFunction2(schema) ? Tuple(schema.parameters, options) : Never();
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
-var Ordinal = 0;
-function Recursive(callback, options = {}) {
-  if (IsUndefined(options.$id))
-    options.$id = `T${Ordinal++}`;
-  const thisType = CloneType(callback({ [Kind]: "This", $ref: `${options.$id}` }));
-  thisType.$id = options.$id;
-  return CreateType({ [Hint]: "Recursive", ...thisType }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
-function RegExp2(unresolved, options) {
-  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
-function RestResolve(T) {
-  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
-}
-function Rest(T) {
-  return RestResolve(T);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
-function ReturnType(schema, options) {
-  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
-var TransformDecodeBuilder = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  Decode(decode) {
-    return new TransformEncodeBuilder(this.schema, decode);
-  }
-};
-var TransformEncodeBuilder = class {
-  constructor(schema, decode) {
-    this.schema = schema;
-    this.decode = decode;
-  }
-  EncodeTransform(encode, schema) {
-    const Encode = (value) => schema[TransformKind].Encode(encode(value));
-    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-    const Codec = { Encode, Decode };
-    return { ...schema, [TransformKind]: Codec };
-  }
-  EncodeSchema(encode, schema) {
-    const Codec = { Decode: this.decode, Encode: encode };
-    return { ...schema, [TransformKind]: Codec };
-  }
-  Encode(encode) {
-    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
-  }
-};
-function Transform(schema) {
-  return new TransformDecodeBuilder(schema);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
-function Unsafe(options = {}) {
-  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
-function Void(options) {
-  return CreateType({ [Kind]: "Void", type: "void" }, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
-var type_exports2 = {};
-__export(type_exports2, {
-  Any: () => Any,
-  Argument: () => Argument,
-  Array: () => Array2,
-  AsyncIterator: () => AsyncIterator,
-  Awaited: () => Awaited,
-  BigInt: () => BigInt,
-  Boolean: () => Boolean2,
-  Capitalize: () => Capitalize,
-  Composite: () => Composite,
-  Const: () => Const,
-  Constructor: () => Constructor,
-  ConstructorParameters: () => ConstructorParameters,
-  Date: () => Date2,
-  Enum: () => Enum,
-  Exclude: () => Exclude,
-  Extends: () => Extends,
-  Extract: () => Extract,
-  Function: () => Function,
-  Index: () => Index,
-  InstanceType: () => InstanceType,
-  Instantiate: () => Instantiate,
-  Integer: () => Integer,
-  Intersect: () => Intersect,
-  Iterator: () => Iterator,
-  KeyOf: () => KeyOf,
-  Literal: () => Literal,
-  Lowercase: () => Lowercase,
-  Mapped: () => Mapped,
-  Module: () => Module,
-  Never: () => Never,
-  Not: () => Not,
-  Null: () => Null,
-  Number: () => Number2,
-  Object: () => Object2,
-  Omit: () => Omit,
-  Optional: () => Optional,
-  Parameters: () => Parameters,
-  Partial: () => Partial,
-  Pick: () => Pick,
-  Promise: () => Promise2,
-  Readonly: () => Readonly,
-  ReadonlyOptional: () => ReadonlyOptional,
-  Record: () => Record,
-  Recursive: () => Recursive,
-  Ref: () => Ref,
-  RegExp: () => RegExp2,
-  Required: () => Required,
-  Rest: () => Rest,
-  ReturnType: () => ReturnType,
-  String: () => String2,
-  Symbol: () => Symbol2,
-  TemplateLiteral: () => TemplateLiteral,
-  Transform: () => Transform,
-  Tuple: () => Tuple,
-  Uint8Array: () => Uint8Array2,
-  Uncapitalize: () => Uncapitalize,
-  Undefined: () => Undefined,
-  Union: () => Union,
-  Unknown: () => Unknown,
-  Unsafe: () => Unsafe,
-  Uppercase: () => Uppercase,
-  Void: () => Void
-});
-
-// node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
-var Type = type_exports2;
-
-// src/runtime/tools/send-file-tool.ts
-var SendFileParams = Type.Object({
-  filePath: Type.String({
-    description: "Absolute path to the file to send to the user. The file must exist and be readable."
-  }),
-  caption: Type.Optional(
-    Type.String({
-      description: "Optional caption or description to accompany the file."
-    })
-  )
-});
-var MIME_BY_EXT = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".pdf": "application/pdf",
-  ".csv": "text/csv",
-  ".json": "application/json",
-  ".txt": "text/plain",
-  ".md": "text/markdown",
-  ".html": "text/html",
-  ".xml": "application/xml",
-  ".zip": "application/zip",
-  ".mp3": "audio/mpeg",
-  ".mp4": "video/mp4",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg"
-};
-function detectMimeType(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
-  return MIME_BY_EXT[ext];
-}
-function createSendFileTool(fileOutputCallbackRef) {
-  return {
-    name: "send_file",
-    label: "Send File",
-    description: "Send a file to the user via the current chat channel (Telegram, Slack, or Web). IMPORTANT: Do NOT proactively send files. Only use this tool when the user EXPLICITLY asks you to send, share, or deliver a file (e.g. '\u628A\u6587\u4EF6\u53D1\u7ED9\u6211', 'send me the file', 'share the result'). Never send intermediate/temporary files. When the user asks, send only the specific file(s) the user requested, not all generated files.",
-    promptSnippet: "send_file: Send a file to the user ONLY when they explicitly request it. Never send files proactively or automatically.",
-    parameters: SendFileParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const { filePath, caption } = params;
-      if (!fs7.existsSync(filePath)) {
-        return {
-          content: [{ type: "text", text: `Error: File not found: ${filePath}` }],
-          details: void 0
-        };
-      }
-      const stats = fs7.statSync(filePath);
-      if (!stats.isFile()) {
-        return {
-          content: [
-            { type: "text", text: `Error: Path is not a file: ${filePath}` }
-          ],
-          details: void 0
-        };
-      }
-      const filename = path7.basename(filePath);
-      const mimeType = detectMimeType(filePath);
-      const callback = fileOutputCallbackRef.current;
-      if (callback) {
-        callback({
-          type: "file_output",
-          filePath,
-          filename,
-          mimeType,
-          caption
-        });
-      }
-      const sizeKB = (stats.size / 1024).toFixed(1);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `File "${filename}" (${sizeKB}KB) has been sent to the user.`
-          }
-        ],
-        details: void 0
-      };
-    }
-  };
-}
-
-// src/runtime/tools/manage-schedule-tool.ts
-var ManageScheduleParams = Type.Object({
-  action: Type.Union(
-    [
-      Type.Literal("add"),
-      Type.Literal("list"),
-      Type.Literal("remove"),
-      Type.Literal("trigger"),
-      Type.Literal("enable"),
-      Type.Literal("disable")
-    ],
-    { description: "The action to perform." }
-  ),
-  name: Type.Optional(
-    Type.String({
-      description: "Unique name for the scheduled task. Required for add/remove/trigger/enable/disable."
-    })
-  ),
-  cron: Type.Optional(
-    Type.String({
-      description: "Cron expression (5 fields: minute hour day month weekday). Required for add."
-    })
-  ),
-  prompt: Type.Optional(
-    Type.String({
-      description: "The work prompt to execute when the task triggers. Required for add. Describe only what to do each run; do not repeat timing, cron, or 'every N minutes' instructions here."
-    })
-  ),
-  timezone: Type.Optional(
-    Type.String({
-      description: "Optional timezone for the cron schedule, e.g. 'Asia/Shanghai', 'America/New_York'."
-    })
-  )
-});
-function textResult(text) {
-  return { content: [{ type: "text", text }], details: void 0 };
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: void 0 };
 }
 function createManageScheduleTool(schedulerRef, adapter, channelId) {
   return {
@@ -5861,6 +3288,9 @@ ${text}`;
   /** Reserved: restore a historical session */
   async restoreSession(_sessionId) {
   }
+  getActiveChannelIds() {
+    return Array.from(this.channels.keys());
+  }
 };
 
 // src/runtime/adapters/web.ts
@@ -5896,9 +3326,11 @@ var WebAdapter = class {
   name = "web";
   wss = null;
   agent = null;
+  ipcBroadcaster = null;
   async start(ctx) {
     const { agent, server, app, rootDir, lifecycle } = ctx;
     this.agent = agent;
+    this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
     const currentConf = configManager.getConfig();
     let apiKey = currentConf.apiKey || "";
     let currentProvider = currentConf.provider || "openai";
@@ -6174,6 +3606,7 @@ var WebAdapter = class {
         }
         const onEvent = (event) => {
           sendWsEvent(ws, event);
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         const result = await agent.handleMessage("web", channelId, text, onEvent);
         if (result.errorMessage) {
@@ -6191,6 +3624,378 @@ var WebAdapter = class {
   }
 };
 
+// src/runtime/adapters/ipc.ts
+init_config();
+
+// src/runtime/services/conversation.ts
+import fs11 from "fs";
+import path11 from "path";
+import {
+  parseSessionEntries
+} from "@mariozechner/pi-coding-agent";
+var ConversationService = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Scan data/sessions and return conversation summaries sorted by recency.
+   */
+  listConversations(activeChannels) {
+    const sessionsDir = path11.resolve(this.rootDir, "data", "sessions");
+    const channelIds = new Set(activeChannels);
+    if (fs11.existsSync(sessionsDir)) {
+      for (const entry of fs11.readdirSync(sessionsDir)) {
+        const channelDir = path11.join(sessionsDir, entry);
+        try {
+          if (fs11.statSync(channelDir).isDirectory()) {
+            channelIds.add(entry);
+          }
+        } catch {
+        }
+      }
+    }
+    const results = [];
+    for (const channelId of channelIds) {
+      const channelDir = path11.join(sessionsDir, channelId);
+      const sessionFile = this.findLatestSessionFile(channelDir);
+      let messageCount = 0;
+      let lastMessageAt = "";
+      let lastMessagePreview = "";
+      if (sessionFile) {
+        const entries = this.loadEntries(sessionFile);
+        const messages = entries.filter(
+          (entry) => entry.type === "message"
+        );
+        messageCount = messages.length;
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage) {
+          lastMessageAt = lastMessage.timestamp;
+          lastMessagePreview = this.extractTextPreview(lastMessage, 100);
+        }
+      }
+      results.push({
+        channelId,
+        platform: this.detectPlatform(channelId),
+        sessionFile,
+        messageCount,
+        lastMessageAt,
+        lastMessagePreview
+      });
+    }
+    return results.sort((a, b) => {
+      const recency = (b.lastMessageAt || "").localeCompare(a.lastMessageAt || "");
+      if (recency !== 0) return recency;
+      return a.channelId.localeCompare(b.channelId);
+    });
+  }
+  /**
+   * Load latest messages for a channel in a simplified format.
+   */
+  getMessages(channelId, limit = 100) {
+    const channelDir = path11.resolve(
+      this.rootDir,
+      "data",
+      "sessions",
+      channelId
+    );
+    const sessionFile = this.findLatestSessionFile(channelDir);
+    if (!sessionFile) return [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 100;
+    if (safeLimit === 0) return [];
+    const entries = this.loadEntries(sessionFile);
+    const messages = [];
+    for (const entry of entries) {
+      if (entry.type !== "message") continue;
+      const role = entry.message?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const text = this.extractText(entry.message);
+      if (!text) continue;
+      const toolCalls = role === "assistant" ? this.extractToolCallSummaries(entry.message) : void 0;
+      messages.push({
+        id: entry.id,
+        role,
+        text,
+        timestamp: entry.timestamp,
+        toolCalls
+      });
+    }
+    return messages.slice(-safeLimit);
+  }
+  findLatestSessionFile(channelDir) {
+    if (!fs11.existsSync(channelDir)) return null;
+    let stats;
+    try {
+      stats = fs11.statSync(channelDir);
+    } catch {
+      return null;
+    }
+    if (!stats.isDirectory()) return null;
+    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path11.join(channelDir, files[0]) : null;
+  }
+  loadEntries(filePath) {
+    try {
+      const content = fs11.readFileSync(filePath, "utf-8");
+      const fileEntries = parseSessionEntries(content);
+      return fileEntries.filter((entry) => entry.type !== "session");
+    } catch (err) {
+      console.warn(`[ConversationService] Failed to load ${filePath}:`, err);
+      return [];
+    }
+  }
+  extractText(message) {
+    if (!message?.content) return "";
+    if (typeof message.content === "string") return message.content.trim();
+    if (!Array.isArray(message.content)) return "";
+    return message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  }
+  extractTextPreview(entry, maxLen) {
+    const text = this.extractText(entry.message);
+    return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+  }
+  extractToolCallSummaries(message) {
+    if (!Array.isArray(message?.content)) return void 0;
+    const toolCalls = message.content.filter((item) => item?.type === "toolCall").map((item) => ({
+      name: typeof item?.name === "string" && item.name ? item.name : "unknown",
+      isError: false
+    }));
+    return toolCalls.length > 0 ? toolCalls : void 0;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+};
+
+// src/runtime/adapters/ipc.ts
+init_types();
+var IpcAdapter = class {
+  name = "ipc";
+  agent = null;
+  rootDir = "";
+  adapterMap = null;
+  conversationService = null;
+  createdChannels = /* @__PURE__ */ new Set();
+  messageListener;
+  started = false;
+  async start(ctx) {
+    if (typeof process.send !== "function") {
+      return;
+    }
+    this.agent = ctx.agent;
+    this.rootDir = ctx.rootDir;
+    this.adapterMap = ctx.adapterMap ?? null;
+    this.conversationService = new ConversationService(ctx.rootDir);
+    this.messageListener = (message) => {
+      if (!this.isIpcRequest(message)) return;
+      void this.handleRequest(message);
+    };
+    process.on("message", this.messageListener);
+    this.started = true;
+    console.log("[IpcAdapter] Started");
+  }
+  async stop() {
+    if (this.messageListener) {
+      process.off("message", this.messageListener);
+      this.messageListener = void 0;
+    }
+    if (this.started) {
+      console.log("[IpcAdapter] Stopped");
+    }
+    this.started = false;
+  }
+  notifyReady(port) {
+    this.sendIpc({
+      type: "ready",
+      port
+    });
+  }
+  broadcastInbound(channelId, platform, sender, text) {
+    this.sendIpc({
+      type: "inbound_message",
+      channelId,
+      platform,
+      sender,
+      text,
+      timestamp: Date.now()
+    });
+  }
+  broadcastAgentEvent(channelId, event) {
+    this.sendIpc({
+      type: "agent_event",
+      channelId,
+      event
+    });
+  }
+  isIpcRequest(message) {
+    if (!message || typeof message !== "object") return false;
+    const maybe = message;
+    return typeof maybe.id === "string" && typeof maybe.type === "string";
+  }
+  async handleRequest(request) {
+    if (!this.agent || !this.conversationService) {
+      this.replyError(request.id, "IPC adapter is not ready yet");
+      return;
+    }
+    try {
+      switch (request.type) {
+        case "get_conversations": {
+          const activeChannels = new Set(this.agent.getActiveChannelIds());
+          for (const channelId of this.createdChannels) {
+            activeChannels.add(channelId);
+          }
+          const conversations = this.conversationService.listConversations(activeChannels);
+          this.reply(request.id, conversations);
+          return;
+        }
+        case "create_conversation": {
+          const channelId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+          this.createdChannels.add(channelId);
+          this.reply(request.id, { channelId });
+          return;
+        }
+        case "get_messages": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const messages = this.conversationService.getMessages(
+            request.channelId,
+            request.limit ?? 100
+          );
+          this.reply(request.id, messages);
+          return;
+        }
+        case "send_message": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          if (typeof request.text !== "string") {
+            this.replyError(request.id, "text is required");
+            return;
+          }
+          const platform = this.detectPlatform(request.channelId);
+          this.createdChannels.add(request.channelId);
+          let fullText = "";
+          const result = await this.agent.handleMessage(
+            platform,
+            request.channelId,
+            request.text,
+            (event) => {
+              if (event.type === "text_delta") {
+                fullText += event.delta;
+              }
+              this.broadcastAgentEvent(request.channelId, event);
+            }
+          );
+          if (fullText.trim() && platform !== "web" && platform !== "scheduler") {
+            const adapter = this.adapterMap?.get(platform);
+            if (adapter && isMessageSender(adapter)) {
+              await adapter.sendMessage(request.channelId, fullText);
+            }
+          }
+          this.reply(request.id, {
+            ...result,
+            text: fullText
+          });
+          return;
+        }
+        case "command": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const result = await this.agent.handleCommand(request.command, request.channelId);
+          this.reply(request.id, result);
+          return;
+        }
+        case "get_config": {
+          this.reply(request.id, configManager.getConfig());
+          return;
+        }
+        case "update_config": {
+          configManager.save(this.rootDir, request.updates || {});
+          const updated = configManager.getConfig();
+          const provider = updated.provider || "openai";
+          this.agent.updateAuth(provider, updated.apiKey);
+          this.reply(request.id, updated);
+          return;
+        }
+        case "get_status": {
+          this.reply(request.id, {
+            status: "running",
+            pid: process.pid
+          });
+          return;
+        }
+        case "get_scheduled_jobs": {
+          const scheduler = this.getSchedulerAdapter();
+          this.reply(request.id, scheduler ? scheduler.listJobs() : []);
+          return;
+        }
+        case "add_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.addJob(request.job);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+        case "remove_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.removeJob(request.name);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+      }
+    } catch (err) {
+      this.replyError(
+        request.id,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  getSchedulerAdapter() {
+    const adapter = this.adapterMap?.get("scheduler");
+    if (!adapter) return null;
+    return adapter;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+  sendIpc(payload) {
+    if (typeof process.send === "function") {
+      process.send(payload);
+    }
+  }
+  reply(id, data) {
+    this.sendIpc({ id, type: "result", data });
+  }
+  replyError(id, message) {
+    this.sendIpc({ id, type: "error", message });
+  }
+};
+
 // src/runtime/server.ts
 init_config();
 
@@ -6267,28 +4072,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs11 from "fs";
+import fs12 from "fs";
 import os from "os";
-import path11 from "path";
-var SKILLPACK_HOME = path11.join(os.homedir(), ".skillpack");
-var LEGACY_REGISTRY_FILE = path11.join(SKILLPACK_HOME, "registry.json");
-var REGISTRY_DIR = path11.join(SKILLPACK_HOME, "registry.d");
+import path12 from "path";
+var SKILLPACK_HOME = path12.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path12.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path12.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs11.existsSync(SKILLPACK_HOME)) {
-    fs11.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs12.existsSync(SKILLPACK_HOME)) {
+    fs12.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs11.existsSync(REGISTRY_DIR)) {
-    fs11.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs12.existsSync(REGISTRY_DIR)) {
+    fs12.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path11.resolve(dir);
+  const resolved = path12.resolve(dir);
   try {
-    return fs11.realpathSync(resolved);
+    return fs12.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -6297,7 +4102,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path11.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path12.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -6305,11 +4110,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs11.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path11.join(REGISTRY_DIR, file));
+  return fs12.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path12.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs11.readFileSync(filePath, "utf-8");
+    const raw = fs12.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
       return null;
@@ -6342,8 +4147,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs11.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs11.renameSync(tmpPath, entryPath);
+  fs12.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs12.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -6351,14 +4156,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs11.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs12.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs11.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs12.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -6371,7 +4176,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs11.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs12.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -6424,7 +4229,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path13.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path14.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -6440,8 +4245,8 @@ async function startServer(options) {
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = dataConfig.modelId?.trim() || (SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId);
   const apiProtocol = dataConfig.apiProtocol;
-  const packageRoot = path13.resolve(__dirname, "..");
-  const webDir = fs14.existsSync(path13.join(rootDir, "web")) ? path13.join(rootDir, "web") : path13.join(packageRoot, "web");
+  const packageRoot = path14.resolve(__dirname, "..");
+  const webDir = fs15.existsSync(path14.join(rootDir, "web")) ? path14.join(rootDir, "web") : path14.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -6470,8 +4275,31 @@ async function startServer(options) {
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
+  const hasIpcChannel = typeof process.send === "function";
+  const ipcAdapter = new IpcAdapter();
+  if (hasIpcChannel) {
+    await ipcAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      adapterMap
+    });
+    adapters.push(ipcAdapter);
+    adapterMap.set(ipcAdapter.name, ipcAdapter);
+  }
+  const ipcBroadcaster = hasIpcChannel ? ipcAdapter : void 0;
   const webAdapter = new WebAdapter();
-  await webAdapter.start({ agent, server, app, rootDir, lifecycle, adapterMap });
+  await webAdapter.start({
+    agent,
+    server,
+    app,
+    rootDir,
+    lifecycle,
+    adapterMap,
+    ipcBroadcaster
+  });
   adapters.push(webAdapter);
   adapterMap.set(webAdapter.name, webAdapter);
   if (dataConfig.adapters?.telegram?.token) {
@@ -6480,7 +4308,15 @@ async function startServer(options) {
       const telegramAdapter = new TelegramAdapter2({
         token: dataConfig.adapters.telegram.token
       });
-      await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
+      await telegramAdapter.start({
+        agent,
+        server,
+        app,
+        rootDir,
+        lifecycle,
+        adapterMap,
+        ipcBroadcaster
+      });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
     } catch (err) {
@@ -6500,7 +4336,15 @@ async function startServer(options) {
           botToken: slackConfig.botToken,
           appToken: slackConfig.appToken
         });
-        await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
+        await slackAdapter.start({
+          agent,
+          server,
+          app,
+          rootDir,
+          lifecycle,
+          adapterMap,
+          ipcBroadcaster
+        });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
       } catch (err) {
@@ -6563,6 +4407,9 @@ async function startServer(options) {
     } catch (err) {
       console.warn("  [Registry] Could not register pack:", err);
     }
+    if (hasIpcChannel) {
+      ipcAdapter.notifyReady(typeof actualPort === "number" ? actualPort : port);
+    }
     if (!daemonRun) {
       const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
       exec(cmd, (err) => {
@@ -6610,23 +4457,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path14.resolve(
+  const templateDir = path15.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path14.join(templateDir, file);
-    const dest = path14.join(workDir, file);
-    if (fs15.existsSync(src)) {
-      fs15.copyFileSync(src, dest);
+    const src = path15.join(templateDir, file);
+    const dest = path15.join(workDir, file);
+    if (fs16.existsSync(src)) {
+      fs16.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs15.chmodSync(dest, 493);
+        fs16.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path14.resolve(directory) : process.cwd();
-  fs15.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path15.resolve(directory) : process.cwd();
+  fs16.mkdirSync(workDir, { recursive: true });
   if (!configExists(workDir)) {
     console.log(chalk4.blue("\n  No skillpack.json found. Let's set one up.\n"));
     const { name, description } = await inquirer2.prompt([
@@ -6671,11 +4518,14 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs16 from "fs";
+import fs17 from "fs";
+import path16 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var packageJson = JSON.parse(
-  fs16.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs17.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
+var cliFilePath = path16.resolve(fileURLToPath3(import.meta.url));
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);
 program.command("create [directory]").description("Create a skills pack interactively").option("--config <path-or-url>", "Initialize from a local or remote skillpack.json").action(async (directory, options) => {
   await createCommand(directory, options);
@@ -6693,4 +4543,12 @@ program.command("zip").description("Package the current pack as a zip file (skil
     process.exit(1);
   }
 });
-program.parse();
+function normalizeUserArgs(argv) {
+  if (argv.length === 0) return argv;
+  const firstArg = argv[0];
+  if (firstArg && path16.resolve(firstArg) === cliFilePath) {
+    return argv.slice(1);
+  }
+  return argv;
+}
+program.parse(normalizeUserArgs(process.argv.slice(2)), { from: "user" });