@ai-setting/roy-agent-core 1.5.17-beta.1 → 1.5.23

package/dist/shared/@ai-setting/roy-agent-core-8jxva565.js

@@ -0,0 +1,19 @@
+import {
+  BUILT_IN_EVENT_SOURCE_TYPES,
+  BUILT_IN_EVENT_SOURCE_TYPE_LIST,
+  EventSourceInitHooks,
+  getDefaultConfigForType,
+  isBuiltInEventSourceType,
+  isValidEventSourceType,
+  validateEventSourceConfig
+} from "./roy-agent-core-avq1x4t7.js";
+import"./roy-agent-core-fs0mn2jk.js";
+export {
+  validateEventSourceConfig,
+  isValidEventSourceType,
+  isBuiltInEventSourceType,
+  getDefaultConfigForType,
+  EventSourceInitHooks,
+  BUILT_IN_EVENT_SOURCE_TYPE_LIST,
+  BUILT_IN_EVENT_SOURCE_TYPES
+};

package/dist/shared/@ai-setting/roy-agent-core-avq1x4t7.js

@@ -0,0 +1,84 @@
+// src/env/event-source/types.ts
+var BUILT_IN_EVENT_SOURCE_TYPES = {
+  LARK_CLI: "lark-cli",
+  WEBSOCKET: "websocket",
+  TIMER: "timer",
+  HTTP_WEBHOOK: "http-webhook",
+  FILE_WATCHER: "file-watcher"
+};
+var BUILT_IN_EVENT_SOURCE_TYPE_LIST = Object.values(BUILT_IN_EVENT_SOURCE_TYPES);
+
+class EventSourceInitHooks {
+  static hooks = new Map;
+  static register(name, hook) {
+    this.hooks.set(name, hook);
+  }
+  static unregister(name) {
+    this.hooks.delete(name);
+  }
+  static list() {
+    return new Map(this.hooks);
+  }
+  static async execute(component) {
+    for (const [name, hook] of this.hooks) {
+      try {
+        await hook(component);
+      } catch (error) {
+        process.stderr.write(`[EventSourceInitHooks] Failed to execute hook "${name}": ${error}
+`);
+      }
+    }
+  }
+  static clear() {
+    this.hooks.clear();
+  }
+}
+function isBuiltInEventSourceType(type) {
+  return BUILT_IN_EVENT_SOURCE_TYPE_LIST.includes(type);
+}
+function isValidEventSourceType(type) {
+  return isBuiltInEventSourceType(type);
+}
+function getDefaultConfigForType(type) {
+  switch (type) {
+    case BUILT_IN_EVENT_SOURCE_TYPES.TIMER:
+      return { interval: 60000 };
+    case BUILT_IN_EVENT_SOURCE_TYPES.LARK_CLI:
+      return { command: "lark-cli event +subscribe" };
+    case BUILT_IN_EVENT_SOURCE_TYPES.WEBSOCKET:
+      return {};
+    default:
+      return {};
+  }
+}
+function validateEventSourceConfig(config, handler) {
+  const errors = [];
+  if (!config.id) {
+    errors.push("EventSource ID is required");
+  }
+  if (!config.name) {
+    errors.push("EventSource name is required");
+  }
+  if (!config.type) {
+    errors.push("EventSource type is required");
+  }
+  if (handler) {
+    const handlerErrors = handler.validateConfig(config);
+    errors.push(...handlerErrors);
+  } else {
+    if (config.type === BUILT_IN_EVENT_SOURCE_TYPES.TIMER) {
+      if (!config.interval || config.interval <= 0) {
+        errors.push("Timer interval must be a positive number");
+      }
+    }
+    if (config.type === BUILT_IN_EVENT_SOURCE_TYPES.LARK_CLI && !config.command) {
+      errors.push("lark-cli command is required");
+    }
+    if (config.type === BUILT_IN_EVENT_SOURCE_TYPES.WEBSOCKET && !config.url) {
+      errors.push("WebSocket URL is required");
+    }
+  }
+  return errors;
+}
+
+export { BUILT_IN_EVENT_SOURCE_TYPES, BUILT_IN_EVENT_SOURCE_TYPE_LIST, EventSourceInitHooks, isBuiltInEventSourceType, isValidEventSourceType, getDefaultConfigForType, validateEventSourceConfig };

package/dist/shared/@ai-setting/{roy-agent-core-gq20wsgv.js → roy-agent-core-ffb9fq4v.js}

@@ -23,6 +23,7 @@ function inferNextNode(messages, definition) {
         agentSessionId: metadata.agentSessionId
       };
     case "workflow.node.end":
+    case "workflow.node.result":
       return getNextNodes(metadata.workflowNodeId, definition);
     default:
       const lastStart = findLastStartMessage(messages);
@@ -34,6 +35,15 @@ function inferNextNode(messages, definition) {
           agentSessionId: startMetadata.agentSessionId
         };
       }
+      const lastCall = findLastCallMessage(messages);
+      if (lastCall) {
+        const callMetadata = lastCall.metadata;
+        return {
+          type: "resume_node",
+          nodeId: callMetadata.workflowNodeId,
+          agentSessionId: callMetadata.agentSessionId
+        };
+      }
       return { type: "entry_node", nodeId: definition.entryNode };
   }
 }
@@ -62,14 +72,24 @@ function findLastStartMessage(messages) {
   }
   return null;
 }
+function findLastCallMessage(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.metadata?.type === "workflow.node.call") {
+      return msg;
+    }
+  }
+  return null;
+}
 function parseNodeOutputs(messages) {
   const outputs = new Map;
   let lastStartNodeId = null;
   for (const msg of messages) {
     const metadata = msg.metadata;
-    if (metadata?.type === "workflow.node.start") {
+    const msgType = metadata?.type;
+    if (msgType === "workflow.node.start" || msgType === "workflow.node.call") {
       lastStartNodeId = metadata.workflowNodeId;
-    } else if (metadata?.type === "workflow.node.end" && lastStartNodeId) {
+    } else if ((msgType === "workflow.node.end" || msgType === "workflow.node.result") && lastStartNodeId) {
       try {
         outputs.set(lastStartNodeId, JSON.parse(msg.content));
       } catch {
@@ -135,5 +155,6 @@ export {
   getAgentSessionIdFromInterrupt,
   findLastStartMessage,
   findLastInterruptMessage,
+  findLastCallMessage,
   extractResumeInfo
 };

package/dist/shared/@ai-setting/roy-agent-core-j1sr5pk9.js

@@ -0,0 +1,424 @@
+import {
+  ContextError,
+  ErrorCodes
+} from "./roy-agent-core-ctdhjv68.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-zgypchmt.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-44hnfb02.js";
+import {
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/environment.ts
+init_logger();
+
+// src/utils/id.ts
+function generateId(prefix = "id") {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function generateDescendingId(prefix = "id") {
+  const timestamp = (Number.MAX_SAFE_INTEGER - Date.now()).toString(36);
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+}
+
+// src/env/environment.ts
+init_decorator();
+import * as fsSync from "fs";
+import * as path from "path";
+var logger = createLogger("environment");
+
+class BaseEnvironment extends BaseComponent {
+  name;
+  version;
+  components = new Map;
+  constructor(config) {
+    super();
+    this.name = config?.name ?? "base-environment";
+    this.version = config?.version ?? "1.0.0";
+    this.registerDefaultComponents();
+  }
+  registerDefaultComponents() {}
+  getConfig() {
+    return {
+      name: this.name,
+      version: this.version,
+      enabled: true,
+      env: this
+    };
+  }
+  registerComponent(component) {
+    this.components.set(component.name, component);
+    logger.debug(`Component registered: ${component.name}`);
+  }
+  unregisterComponent(name) {
+    const component = this.components.get(name);
+    if (component) {
+      this.components.delete(name);
+      logger.debug(`Component unregistered: ${name}`);
+    }
+  }
+  getComponent(name) {
+    return this.components.get(name);
+  }
+  listComponents() {
+    return Array.from(this.components.values());
+  }
+  async handle_query(query, context) {
+    const agentComponent = this.getComponent("agent");
+    if (!agentComponent) {
+      throw new Error("AgentComponent not found. Please register AgentComponent before calling handle_query.");
+    }
+    let systemPrompt = "You are a helpful assistant.";
+    let promptSource = "fallback";
+    try {
+      const promptComponent = this.getComponent("prompt");
+      if (promptComponent) {
+        const loadedPrompt = await promptComponent.getPrompt("default");
+        if (loadedPrompt) {
+          systemPrompt = loadedPrompt;
+          promptSource = "PromptComponent";
+        }
+      }
+    } catch (err) {
+      logger.warn(`[handle_query] Failed to get prompt from PromptComponent: ${err}`);
+    }
+    logger.info(`[handle_query] Using system prompt from ${promptSource}, length: ${systemPrompt.length}`);
+    let finalSystemPrompt = systemPrompt;
+    if (systemPrompt.includes("{{memory}}")) {
+      try {
+        const memoryComponent = this.getComponent("memory");
+        if (memoryComponent) {
+          const memoryContent = await memoryComponent.recallMemory();
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", memoryContent || "(No memory)");
+          logger.info(`[handle_query] Injected memory content, length: ${memoryContent.length}`);
+        } else {
+          finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Memory component not available)");
+        }
+      } catch (err) {
+        logger.warn(`[handle_query] Failed to load memory content: ${err}`);
+        finalSystemPrompt = systemPrompt.replace("{{memory}}", "(Failed to load memory)");
+      }
+    }
+    if (finalSystemPrompt.includes("{{workspace_dir}}")) {
+      const workspaceDir = process.cwd();
+      finalSystemPrompt = finalSystemPrompt.replace("{{workspace_dir}}", workspaceDir);
+      logger.debug(`[handle_query] Injected workspace_dir: ${workspaceDir}`);
+    }
+    const agentName = context?.agentType && context.agentType !== "default" ? context.agentType : "default";
+    let agent = agentComponent.getAgent(agentName);
+    if (!agent) {
+      if (agentName !== "default") {
+        logger.warn(`[handle_query] Agent "${agentName}" not found, falling back to "default"`);
+      }
+      agent = agentComponent.getAgent("default");
+    }
+    if (!agent) {
+      agent = agentComponent.registerAgent("default", {
+        type: "primary",
+        systemPrompt: finalSystemPrompt
+      });
+    }
+    const result = await agentComponent.run(agent.name, query, context);
+    if (result.error) {
+      const errorMsg = result.error.toLowerCase();
+      if (errorMsg.includes("context") || errorMsg.includes("threshold") || errorMsg.includes("token") || result.error.includes("CTX_001")) {
+        const usageMatch = result.error.match(/(\d+)\/(\d+)\s*\(([\d.]+)%\)/);
+        let usage;
+        let contextWindow;
+        if (usageMatch) {
+          const totalTokens = parseInt(usageMatch[1], 10);
+          usage = {
+            promptTokens: totalTokens,
+            completionTokens: 0,
+            totalTokens
+          };
+          contextWindow = parseInt(usageMatch[2], 10);
+        }
+        const ctxError = new ContextError(result.error, ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, context?.sessionId, usage, contextWindow);
+        throw ctxError;
+      }
+      throw new Error(result.error);
+    }
+    return result.finalText || "";
+  }
+  async handle_action(action, context) {
+    throw new Error("handle_action not implemented. Override in subclass.");
+  }
+  eventHandlers = new Map;
+  wildcardHandlers = new Set;
+  subscribe(handler) {
+    this.wildcardHandlers.add(handler);
+    logger.debug(`EnvEvent handler subscribed (wildcard)`);
+    return () => {
+      this.wildcardHandlers.delete(handler);
+      logger.debug(`EnvEvent handler unsubscribed (wildcard)`);
+    };
+  }
+  subscribeTo(eventType, handler) {
+    const types = Array.isArray(eventType) ? eventType : [eventType];
+    for (const type of types) {
+      if (!this.eventHandlers.has(type)) {
+        this.eventHandlers.set(type, new Set);
+      }
+      this.eventHandlers.get(type).add(handler);
+    }
+    logger.debug(`EnvEvent handler subscribed for types: ${types.join(", ")}`);
+    return () => {
+      for (const type of types) {
+        this.eventHandlers.get(type)?.delete(handler);
+      }
+      logger.debug(`EnvEvent handler unsubscribed for types: ${types.join(", ")}`);
+    };
+  }
+  subscribeAll(handler) {
+    return this.subscribe(handler);
+  }
+  pushEnvEvent(event) {
+    const fullEvent = "id" in event && event.id ? event : {
+      id: event.id ?? generateId(),
+      type: event.type,
+      timestamp: event.timestamp ?? Date.now(),
+      metadata: {
+        ...event.metadata,
+        env_name: event.metadata?.env_name ?? this.name
+      },
+      payload: event.payload ?? {}
+    };
+    for (const handler of this.wildcardHandlers) {
+      try {
+        handler(fullEvent);
+      } catch (error) {
+        logger.error(`Error in EnvEvent handler: ${error}`);
+      }
+    }
+    const handlers = this.eventHandlers.get(fullEvent.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(fullEvent);
+        } catch (error) {
+          logger.error(`Error in EnvEvent handler for ${fullEvent.type}: ${error}`);
+        }
+      }
+    }
+  }
+  emit(type, payload, metadata) {
+    const event = {
+      id: generateId(),
+      type,
+      timestamp: Date.now(),
+      metadata: {
+        env_name: this.name,
+        ...metadata
+      },
+      payload
+    };
+    this.pushEnvEvent(event);
+  }
+  async initializeComponents() {
+    logger.debug(`Starting component initialization, total: ${this.components.size}`);
+    const configComp = this.components.get("config");
+    if (configComp && configComp.getStatus() === "created") {
+      logger.debug(`Initializing ConfigComponent first...`);
+      await configComp.init({
+        name: "config",
+        version: configComp.version,
+        enabled: true,
+        env: this
+      });
+      logger.debug(`ConfigComponent initialized`);
+    } else {
+      logger.debug(`No ConfigComponent found, skipping first stage`);
+    }
+    const otherComponents = Array.from(this.components.values()).filter((c) => c.getStatus() === "created");
+    if (otherComponents.length > 0) {
+      logger.debug(`Initializing ${otherComponents.length} other components...`);
+      for (const component of otherComponents) {
+        logger.debug(`Initializing component: ${component.name}`);
+        await component.init({
+          name: component.name,
+          version: component.version,
+          enabled: true,
+          env: this
+        });
+        logger.debug(`Component initialized: ${component.name}`);
+      }
+    }
+    logger.debug(`All components initialized`);
+  }
+  async startComponents() {
+    const allComponents = Array.from(this.components.values());
+    if (allComponents.length > 0) {
+      logger.debug(`Starting ${allComponents.length} components...`);
+      for (const component of allComponents) {
+        logger.debug(`Starting component: ${component.name} (current status: ${component.getStatus()})`);
+        await component.start();
+        logger.debug(`Component started: ${component.name}`);
+      }
+    }
+  }
+  async stopComponents() {
+    const componentsToStop = Array.from(this.components.values()).filter((c) => c.getStatus() !== "stopped");
+    if (componentsToStop.length > 0) {
+      logger.debug(`Stopping ${componentsToStop.length} components...`);
+      for (const component of componentsToStop) {
+        logger.debug(`Stopping component: ${component.name}`);
+        await component.stop();
+        logger.debug(`Component stopped: ${component.name}`);
+      }
+    }
+  }
+  async onInit() {
+    await this.initializeComponents();
+    logger.info(`Environment "${this.name}" initialized`);
+  }
+  async onStart() {
+    await this.startComponents();
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async onStop() {
+    await this.stopComponents();
+    this.eventHandlers.clear();
+    this.wildcardHandlers.clear();
+    logger.info(`Environment "${this.name}" stopped`);
+  }
+  async init() {
+    Object.defineProperty(this, "env", {
+      value: this,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    this.setStatus("initializing");
+    await this.onInit();
+    this.setStatus("running");
+  }
+  async start() {
+    if (this._started)
+      return;
+    this._started = true;
+    await this.onStart();
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" started`);
+  }
+  async stop() {
+    this.setStatus("stopping");
+    await this.onStop();
+    this.setStatus("stopped");
+  }
+  async loadServiceConfig(configPath) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before loading service config.");
+    }
+    const xdgDataHome = configComponent.getXdgDataHome();
+    const fullPath = path.resolve(xdgDataHome, configPath);
+    if (!fsSync.existsSync(fullPath)) {
+      throw new Error(`Service config file not found: ${fullPath}`);
+    }
+    const content = fsSync.readFileSync(fullPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse service config: ${e}`);
+    }
+    logger.debug(`Service config loaded from: ${fullPath}`);
+    return config;
+  }
+  generateComponentOptions(componentName, configEntry) {
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before generating component options.");
+    }
+    const options = {
+      configComponent,
+      configPath: configEntry.configPath,
+      envPrefix: configEntry.envPrefix,
+      config: configEntry.config
+    };
+    logger.debug(`Generated options for component: ${componentName}`);
+    return options;
+  }
+  async registerComponentWithConfig(component, configEntry) {
+    if (!this.components.has(component.name)) {
+      this.registerComponent(component);
+    }
+    const options = this.generateComponentOptions(component.name, configEntry);
+    if (component.getStatus() === "running") {
+      logger.debug(`Component ${component.name} already initialized, skipping`);
+      return;
+    }
+    await component.init({
+      name: component.name,
+      version: component.version,
+      enabled: configEntry.enabled ?? true,
+      env: this,
+      options
+    });
+    logger.debug(`Component ${component.name} registered and initialized with config`);
+  }
+  async initFromConfig(configPath) {
+    if (!this.env) {
+      Object.defineProperty(this, "env", {
+        value: this,
+        writable: true,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    const serviceConfig = await this.loadServiceConfig(configPath);
+    if (serviceConfig.environment) {
+      if (serviceConfig.environment.name) {
+        this.name = serviceConfig.environment.name;
+      }
+      if (serviceConfig.environment.version) {
+        this.version = serviceConfig.environment.version;
+      }
+    }
+    const configComponent = this.getComponent("config");
+    if (!configComponent) {
+      throw new Error("ConfigComponent not found. Please register ConfigComponent before initFromConfig.");
+    }
+    if (configComponent.getStatus() === "created") {
+      await configComponent.init({
+        name: "config",
+        version: configComponent.version,
+        enabled: true,
+        env: this
+      });
+    }
+    const components = serviceConfig.components || {};
+    for (const [componentName, configEntry] of Object.entries(components)) {
+      if (configEntry.enabled === false) {
+        logger.debug(`Component ${componentName} is disabled, skipping`);
+        continue;
+      }
+      const component = this.getComponent(componentName);
+      if (!component) {
+        logger.warn(`Component ${componentName} not registered, skipping`);
+        continue;
+      }
+      if (component.name === "config")
+        continue;
+      await this.registerComponentWithConfig(component, configEntry);
+    }
+    this.setStatus("running");
+    logger.info(`Environment "${this.name}" initialized from config: ${configPath}`);
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("env.handle_query", { recordParams: true, recordResult: true, log: true })
+], BaseEnvironment.prototype, "handle_query", null);
+export { generateId, generateDescendingId, BaseEnvironment };

package/dist/shared/@ai-setting/{roy-agent-core-93zfb3r1.js → roy-agent-core-mrcxzpbg.js}

@@ -142,7 +142,7 @@ Options:
   -s, --session <id>      Specify session ID
   --model <model>         Use specific model
   -C, --config <path>     Config file path
-  -q, --quiet             Quiet mode (default: true)
+  -q, --no-quiet          Enable logging (default: quiet mode is on)
   -r, --reasoning         Show AI reasoning process
   --tool-calls            Show tool calls
   --tool-results          Show tool execution results

package/dist/shared/@ai-setting/{roy-agent-core-rhmtwnw1.js → roy-agent-core-pw7cv1px.js}

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-wrcy0h6z.js";
+} from "./roy-agent-core-ty94k28r.js";
 import {
   WorkflowService
 } from "./roy-agent-core-4t40mkpv.js";

package/dist/shared/@ai-setting/{roy-agent-core-wrcy0h6z.js → roy-agent-core-ty94k28r.js}

@@ -1490,7 +1490,7 @@ var init_engine = __esm(() => {
         }
       }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode } = await import("./roy-agent-core-gq20wsgv.js");
+      const { inferNextNode } = await import("./roy-agent-core-ffb9fq4v.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
       const resumePoint = inferNextNode(messages, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.17-beta.1",
+  "version": "1.5.23",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -27,38 +27,23 @@
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "bunup",
+    "build:main": "bunup -- --entry src/index.ts",
+    "clean": "rm -rf dist",
+    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
+  },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
     "@ai-sdk/google": "^3.0.0",
     "@ai-sdk/openai": "^3.0.0",
     "@ai-sdk/openai-compatible": "^2.0.0",
-    "@hono/node-server": "^2.0.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "ai": "^6.0.0",
-    "ajv": "^8.20.0",
-    "ajv-formats": "^3.0.1",
     "better-sqlite3": "^11.10.0",
-    "content-type": "^2.0.0",
-    "cors": "^2.8.6",
-    "deep-equal": "^2.2.3",
-    "eventsource": "^4.1.0",
-    "express": "^5.2.1",
-    "express-rate-limit": "^8.5.1",
-    "fast-deep-equal": "^3.1.3",
-    "fast-uri": "^3.1.2",
     "glob": "^13.0.6",
-    "hono": "^4.12.18",
-    "jose": "^6.2.3",
-    "json-schema-traverse": "^1.0.0",
-    "json-schema-typed": "^8.0.2",
     "jsonc-parser": "^3.2.0",
-    "pkce-challenge": "^6.0.0",
-    "punycode": "^2.3.1",
-    "raw-body": "^3.0.2",
     "reflect-metadata": "^0.2.2",
-    "require-from-string": "^2.0.2",
-    "uri-js": "^4.4.1",
-    "which": "^7.0.0",
     "ws": "^8.16.0",
     "xdg-basedir": "^5.1.0",
     "yaml": "^2.3.0",
@@ -94,11 +79,5 @@
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/ai-setting/roy-agent/issues"
-  },
-  "scripts": {
-    "build": "bunup",
-    "build:main": "bunup -- --entry src/index.ts",
-    "clean": "rm -rf dist",
-    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
   }
-}
+}