@botpress/adk-cli 1.2.1 → 1.4.0

package/dist/bp-cli/dist/command-implementations/read-command.js

@@ -0,0 +1,89 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var read_command_exports = {};
+__export(read_command_exports, {
+  ReadCommand: () => ReadCommand
+});
+module.exports = __toCommonJS(read_command_exports);
+var apiUtils = __toESM(require("../api"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_project_command = require("./project-command");
+class ReadCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const { projectType, resolveProjectDefinition } = this.readProjectDefinitionFromFS();
+    if (projectType === "integration") {
+      const projectDef = await resolveProjectDefinition();
+      const parsed = await this._parseIntegration(projectDef.definition);
+      this.logger.json(parsed);
+      return;
+    }
+    if (projectType === "interface") {
+      const projectDef = await resolveProjectDefinition();
+      const parsed = await this._parseInterface(projectDef.definition);
+      this.logger.json(parsed);
+      return;
+    }
+    if (projectType === "bot") {
+      const projectDef = await resolveProjectDefinition();
+      const parsed = await this._parseBot(projectDef.definition);
+      this.logger.json(parsed);
+      return;
+    }
+    if (projectType === "plugin") {
+      const projectDef = await resolveProjectDefinition();
+      const parsed = await this._parsePlugin(projectDef.definition);
+      this.logger.json(parsed);
+      return;
+    }
+    throw new errors.BotpressCLIError("Unsupported project type");
+  }
+  _parseIntegration = async (integrationDef) => {
+    const parsed = await apiUtils.prepareCreateIntegrationBody(integrationDef);
+    parsed.interfaces = utils.records.mapValues(integrationDef.interfaces ?? {}, (iface) => ({
+      ...iface,
+      id: iface.id ?? ""
+    }));
+    return parsed;
+  };
+  _parseInterface = async (interfaceDef) => {
+    return await apiUtils.prepareCreateInterfaceBody(interfaceDef);
+  };
+  _parseBot = async (botDef) => {
+    return await apiUtils.prepareCreateBotBody(botDef);
+  };
+  _parsePlugin = async (pluginDef) => {
+    return await apiUtils.prepareCreatePluginBody(pluginDef);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReadCommand
+});
+//# sourceMappingURL=read-command.js.map

package/dist/bp-cli/dist/command-implementations/read-command.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/command-implementations/read-command.ts"],
+  "sourcesContent": ["import * as sdk from '@botpress/sdk'\nimport * as apiUtils from '../api'\nimport commandDefinitions from '../command-definitions'\nimport * as errors from '../errors'\nimport * as utils from '../utils'\nimport { ProjectCommand } from './project-command'\n\nexport type ReadCommandDefinition = typeof commandDefinitions.read\nexport class ReadCommand extends ProjectCommand<ReadCommandDefinition> {\n  public async run(): Promise<void> {\n    const { projectType, resolveProjectDefinition } = this.readProjectDefinitionFromFS()\n    if (projectType === 'integration') {\n      const projectDef = await resolveProjectDefinition()\n      const parsed = await this._parseIntegration(projectDef.definition)\n      this.logger.json(parsed)\n      return\n    }\n    if (projectType === 'interface') {\n      const projectDef = await resolveProjectDefinition()\n      const parsed = await this._parseInterface(projectDef.definition)\n      this.logger.json(parsed)\n      return\n    }\n    if (projectType === 'bot') {\n      const projectDef = await resolveProjectDefinition()\n      const parsed = await this._parseBot(projectDef.definition)\n      this.logger.json(parsed)\n      return\n    }\n    if (projectType === 'plugin') {\n      const projectDef = await resolveProjectDefinition()\n      const parsed = await this._parsePlugin(projectDef.definition)\n      this.logger.json(parsed)\n      return\n    }\n\n    throw new errors.BotpressCLIError('Unsupported project type')\n  }\n\n  private _parseIntegration = async (integrationDef: sdk.IntegrationDefinition) => {\n    const parsed = await apiUtils.prepareCreateIntegrationBody(integrationDef)\n    parsed.interfaces = utils.records.mapValues(integrationDef.interfaces ?? {}, (iface) => ({\n      ...iface,\n      id: iface.id ?? '',\n    }))\n    return parsed\n  }\n\n  private _parseInterface = async (interfaceDef: sdk.InterfaceDefinition) => {\n    return await apiUtils.prepareCreateInterfaceBody(interfaceDef)\n  }\n\n  private _parseBot = async (botDef: sdk.BotDefinition) => {\n    return await apiUtils.prepareCreateBotBody(botDef)\n  }\n\n  private _parsePlugin = async (pluginDef: sdk.PluginDefinition) => {\n    return await apiUtils.prepareCreatePluginBody(pluginDef)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,eAA0B;AAE1B,aAAwB;AACxB,YAAuB;AACvB,6BAA+B;AAGxB,MAAM,oBAAoB,sCAAsC;AAAA,EACrE,MAAa,MAAqB;AAChC,UAAM,EAAE,aAAa,yBAAyB,IAAI,KAAK,4BAA4B;AACnF,QAAI,gBAAgB,eAAe;AACjC,YAAM,aAAa,MAAM,yBAAyB;AAClD,YAAM,SAAS,MAAM,KAAK,kBAAkB,WAAW,UAAU;AACjE,WAAK,OAAO,KAAK,MAAM;AACvB;AAAA,IACF;AACA,QAAI,gBAAgB,aAAa;AAC/B,YAAM,aAAa,MAAM,yBAAyB;AAClD,YAAM,SAAS,MAAM,KAAK,gBAAgB,WAAW,UAAU;AAC/D,WAAK,OAAO,KAAK,MAAM;AACvB;AAAA,IACF;AACA,QAAI,gBAAgB,OAAO;AACzB,YAAM,aAAa,MAAM,yBAAyB;AAClD,YAAM,SAAS,MAAM,KAAK,UAAU,WAAW,UAAU;AACzD,WAAK,OAAO,KAAK,MAAM;AACvB;AAAA,IACF;AACA,QAAI,gBAAgB,UAAU;AAC5B,YAAM,aAAa,MAAM,yBAAyB;AAClD,YAAM,SAAS,MAAM,KAAK,aAAa,WAAW,UAAU;AAC5D,WAAK,OAAO,KAAK,MAAM;AACvB;AAAA,IACF;AAEA,UAAM,IAAI,OAAO,iBAAiB,0BAA0B;AAAA,EAC9D;AAAA,EAEQ,oBAAoB,OAAO,mBAA8C;AAC/E,UAAM,SAAS,MAAM,SAAS,6BAA6B,cAAc;AACzE,WAAO,aAAa,MAAM,QAAQ,UAAU,eAAe,cAAc,CAAC,GAAG,CAAC,WAAW;AAAA,MACvF,GAAG;AAAA,MACH,IAAI,MAAM,MAAM;AAAA,IAClB,EAAE;AACF,WAAO;AAAA,EACT;AAAA,EAEQ,kBAAkB,OAAO,iBAA0C;AACzE,WAAO,MAAM,SAAS,2BAA2B,YAAY;AAAA,EAC/D;AAAA,EAEQ,YAAY,OAAO,WAA8B;AACvD,WAAO,MAAM,SAAS,qBAAqB,MAAM;AAAA,EACnD;AAAA,EAEQ,eAAe,OAAO,cAAoC;AAChE,WAAO,MAAM,SAAS,wBAAwB,SAAS;AAAA,EACzD;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/command-implementations/serve-command.d.ts

@@ -0,0 +1,6 @@
+import type commandDefinitions from '../command-definitions';
+import { ProjectCommand } from './project-command';
+export type ServeCommandDefinition = typeof commandDefinitions.serve;
+export declare class ServeCommand extends ProjectCommand<ServeCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/bp-cli/dist/command-implementations/serve-command.js

@@ -0,0 +1,69 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serve_command_exports = {};
+__export(serve_command_exports, {
+  ServeCommand: () => ServeCommand
+});
+module.exports = __toCommonJS(serve_command_exports);
+var fs = __toESM(require("fs"));
+var errors = __toESM(require("../errors"));
+var utils = __toESM(require("../utils"));
+var import_project_command = require("./project-command");
+class ServeCommand extends import_project_command.ProjectCommand {
+  async run() {
+    const outfile = this.projectPaths.abs.outFileCJS;
+    if (!fs.existsSync(outfile)) {
+      throw new errors.NoBundleFoundError();
+    }
+    const { projectType, resolveProjectDefinition } = this.readProjectDefinitionFromFS();
+    if (projectType === "interface") {
+      throw new errors.BotpressCLIError("An interface project has no implementation to serve.");
+    }
+    if (projectType === "integration") {
+      const projectDef = await resolveProjectDefinition();
+      const secretEnvVariables = await this.promptSecrets(projectDef.definition, this.argv, { formatEnv: true });
+      const nonNullSecretEnvVariables = utils.records.filterValues(secretEnvVariables, utils.guards.is.notNull);
+      for (const [key, value] of Object.entries(nonNullSecretEnvVariables)) {
+        process.env[key] = value;
+      }
+    }
+    this.logger.log(`Serving ${projectType}...`);
+    const { default: serveable } = utils.require.requireJsFile(outfile);
+    const server = await serveable.start(this.argv.port);
+    await new Promise((resolve, reject) => {
+      server.on("error", reject);
+      server.on("close", resolve);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServeCommand
+});
+//# sourceMappingURL=serve-command.js.map

package/dist/bp-cli/dist/command-implementations/serve-command.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/command-implementations/serve-command.ts"],
+  "sourcesContent": ["import type { Bot as BotImpl, Integration as IntegrationImpl } from '@botpress/sdk'\nimport * as fs from 'fs'\nimport type commandDefinitions from '../command-definitions'\nimport * as errors from '../errors'\nimport * as utils from '../utils'\nimport { ProjectCommand } from './project-command'\n\ntype Serveable = BotImpl | IntegrationImpl\n\nexport type ServeCommandDefinition = typeof commandDefinitions.serve\nexport class ServeCommand extends ProjectCommand<ServeCommandDefinition> {\n  public async run(): Promise<void> {\n    const outfile = this.projectPaths.abs.outFileCJS\n    if (!fs.existsSync(outfile)) {\n      throw new errors.NoBundleFoundError()\n    }\n\n    const { projectType, resolveProjectDefinition } = this.readProjectDefinitionFromFS()\n    if (projectType === 'interface') {\n      throw new errors.BotpressCLIError('An interface project has no implementation to serve.')\n    }\n\n    if (projectType === 'integration') {\n      const projectDef = await resolveProjectDefinition()\n      // TODO: store secrets in local cache to avoid prompting every time\n      const secretEnvVariables = await this.promptSecrets(projectDef.definition, this.argv, { formatEnv: true })\n      const nonNullSecretEnvVariables = utils.records.filterValues(secretEnvVariables, utils.guards.is.notNull)\n      for (const [key, value] of Object.entries(nonNullSecretEnvVariables)) {\n        process.env[key] = value\n      }\n    }\n\n    this.logger.log(`Serving ${projectType}...`)\n\n    const { default: serveable } = utils.require.requireJsFile<{ default: Serveable }>(outfile)\n    const server = await serveable.start(this.argv.port)\n\n    await new Promise<void>((resolve, reject) => {\n      server.on('error', reject)\n      server.on('close', resolve)\n    })\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,SAAoB;AAEpB,aAAwB;AACxB,YAAuB;AACvB,6BAA+B;AAKxB,MAAM,qBAAqB,sCAAuC;AAAA,EACvE,MAAa,MAAqB;AAChC,UAAM,UAAU,KAAK,aAAa,IAAI;AACtC,QAAI,CAAC,GAAG,WAAW,OAAO,GAAG;AAC3B,YAAM,IAAI,OAAO,mBAAmB;AAAA,IACtC;AAEA,UAAM,EAAE,aAAa,yBAAyB,IAAI,KAAK,4BAA4B;AACnF,QAAI,gBAAgB,aAAa;AAC/B,YAAM,IAAI,OAAO,iBAAiB,sDAAsD;AAAA,IAC1F;AAEA,QAAI,gBAAgB,eAAe;AACjC,YAAM,aAAa,MAAM,yBAAyB;AAElD,YAAM,qBAAqB,MAAM,KAAK,cAAc,WAAW,YAAY,KAAK,MAAM,EAAE,WAAW,KAAK,CAAC;AACzG,YAAM,4BAA4B,MAAM,QAAQ,aAAa,oBAAoB,MAAM,OAAO,GAAG,OAAO;AACxG,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,yBAAyB,GAAG;AACpE,gBAAQ,IAAI,GAAG,IAAI;AAAA,MACrB;AAAA,IACF;AAEA,SAAK,OAAO,IAAI,WAAW,WAAW,KAAK;AAE3C,UAAM,EAAE,SAAS,UAAU,IAAI,MAAM,QAAQ,cAAsC,OAAO;AAC1F,UAAM,SAAS,MAAM,UAAU,MAAM,KAAK,KAAK,IAAI;AAEnD,UAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAC3C,aAAO,GAAG,SAAS,MAAM;AACzB,aAAO,GAAG,SAAS,OAAO;AAAA,IAC5B,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/bp-cli/dist/command-tree.d.ts

@@ -0,0 +1,39 @@
+import type * as typings from './typings';
+export type DefinitionSubTree = {
+    description: string;
+    subcommands: DefinitionTree;
+};
+export type DefinitionTree = {
+    [key: string]: DefinitionTreeNode;
+};
+export type DefinitionTreeNode = typings.CommandDefinition | DefinitionSubTree;
+export type ImplementationSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
+    subcommands: ImplementationTree<D['subcommands']>;
+};
+export type ImplementationTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandImplementation<N> : N extends DefinitionSubTree ? ImplementationSubTree<N> : never;
+export type ImplementationTree<D extends DefinitionTree = DefinitionTree> = {
+    [K in keyof D]: ImplementationTreeNode<D[K]>;
+};
+export type CommandSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
+    description: string;
+    subcommands: CommandTree<D['subcommands']>;
+};
+export type CommandTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandLeaf<N> : N extends DefinitionSubTree ? CommandSubTree<N> : never;
+export type CommandTree<D extends DefinitionTree = DefinitionTree> = {
+    [K in keyof D]: CommandTreeNode<D[K]>;
+};
+export declare const guards: {
+    definition: {
+        isDef: (x: DefinitionTreeNode) => x is typings.CommandDefinition;
+        isSubTree: (x: DefinitionTreeNode) => x is DefinitionSubTree;
+    };
+    implementation: {
+        isImpl: (x: ImplementationTreeNode) => x is typings.CommandImplementation;
+        isSubTree: (x: ImplementationTreeNode) => x is ImplementationSubTree;
+    };
+    command: {
+        isLeaf: (x: CommandTreeNode) => x is typings.CommandLeaf;
+        isSubTree: (x: CommandTreeNode) => x is CommandSubTree;
+    };
+};
+export declare const zipTree: <T extends DefinitionTree>(defTree: T, implTree: ImplementationTree<T>) => CommandTree<T>;

package/dist/bp-cli/dist/command-tree.js

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_tree_exports = {};
+__export(command_tree_exports, {
+  guards: () => guards,
+  zipTree: () => zipTree
+});
+module.exports = __toCommonJS(command_tree_exports);
+const guards = {
+  definition: {
+    isDef: (x) => "schema" in x,
+    isSubTree: (x) => "subcommands" in x
+  },
+  implementation: {
+    isImpl: (x) => typeof x === "function",
+    isSubTree: (x) => typeof x === "object"
+  },
+  command: {
+    isLeaf: (x) => "handler" in x,
+    isSubTree: (x) => "subcommands" in x
+  }
+};
+const zipTree = (defTree, implTree) => {
+  const tree = {};
+  for (const key in defTree) {
+    const def = defTree[key];
+    const impl = implTree[key];
+    if (guards.definition.isDef(def) && guards.implementation.isImpl(impl)) {
+      tree[key] = { ...def, handler: impl };
+      continue;
+    }
+    if (guards.definition.isSubTree(def) && guards.implementation.isSubTree(impl)) {
+      tree[key] = { ...def, subcommands: zipTree(def.subcommands, impl.subcommands) };
+      continue;
+    }
+  }
+  return tree;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guards,
+  zipTree
+});
+//# sourceMappingURL=command-tree.js.map

package/dist/bp-cli/dist/command-tree.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/command-tree.ts"],
+  "sourcesContent": ["import type * as typings from './typings'\n\nexport type DefinitionSubTree = {\n  description: string\n  subcommands: DefinitionTree\n}\n\nexport type DefinitionTree = {\n  [key: string]: DefinitionTreeNode\n}\n\nexport type DefinitionTreeNode = typings.CommandDefinition | DefinitionSubTree\n\nexport type ImplementationSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {\n  subcommands: ImplementationTree<D['subcommands']>\n}\n\nexport type ImplementationTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> =\n  N extends typings.CommandDefinition\n    ? typings.CommandImplementation<N>\n    : N extends DefinitionSubTree\n      ? ImplementationSubTree<N>\n      : never\n\nexport type ImplementationTree<D extends DefinitionTree = DefinitionTree> = {\n  [K in keyof D]: ImplementationTreeNode<D[K]>\n}\n\nexport type CommandSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {\n  description: string\n  subcommands: CommandTree<D['subcommands']>\n}\n\nexport type CommandTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition\n  ? typings.CommandLeaf<N>\n  : N extends DefinitionSubTree\n    ? CommandSubTree<N>\n    : never\n\nexport type CommandTree<D extends DefinitionTree = DefinitionTree> = {\n  [K in keyof D]: CommandTreeNode<D[K]>\n}\n\nexport const guards = {\n  definition: {\n    isDef: (x: DefinitionTreeNode): x is typings.CommandDefinition => 'schema' in x,\n    isSubTree: (x: DefinitionTreeNode): x is DefinitionSubTree => 'subcommands' in x,\n  },\n  implementation: {\n    isImpl: (x: ImplementationTreeNode): x is typings.CommandImplementation => typeof x === 'function',\n    isSubTree: (x: ImplementationTreeNode): x is ImplementationSubTree => typeof x === 'object',\n  },\n  command: {\n    isLeaf: (x: CommandTreeNode): x is typings.CommandLeaf => 'handler' in x,\n    isSubTree: (x: CommandTreeNode): x is CommandSubTree => 'subcommands' in x,\n  },\n}\n\nexport const zipTree = <T extends DefinitionTree>(defTree: T, implTree: ImplementationTree<T>): CommandTree<T> => {\n  const tree = {} as CommandTree<T>\n\n  for (const key in defTree) {\n    const def = defTree[key]!\n    const impl = implTree[key]!\n\n    if (guards.definition.isDef(def) && guards.implementation.isImpl(impl)) {\n      tree[key] = { ...def, handler: impl } as CommandTreeNode<typeof def>\n      continue\n    }\n\n    if (guards.definition.isSubTree(def) && guards.implementation.isSubTree(impl)) {\n      tree[key] = { ...def, subcommands: zipTree(def.subcommands, impl.subcommands) } as CommandTreeNode<typeof def>\n      continue\n    }\n  }\n\n  return tree\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2CO,MAAM,SAAS;AAAA,EACpB,YAAY;AAAA,IACV,OAAO,CAAC,MAA0D,YAAY;AAAA,IAC9E,WAAW,CAAC,MAAkD,iBAAiB;AAAA,EACjF;AAAA,EACA,gBAAgB;AAAA,IACd,QAAQ,CAAC,MAAkE,OAAO,MAAM;AAAA,IACxF,WAAW,CAAC,MAA0D,OAAO,MAAM;AAAA,EACrF;AAAA,EACA,SAAS;AAAA,IACP,QAAQ,CAAC,MAAiD,aAAa;AAAA,IACvE,WAAW,CAAC,MAA4C,iBAAiB;AAAA,EAC3E;AACF;AAEO,MAAM,UAAU,CAA2B,SAAY,aAAoD;AAChH,QAAM,OAAO,CAAC;AAEd,aAAW,OAAO,SAAS;AACzB,UAAM,MAAM,QAAQ,GAAG;AACvB,UAAM,OAAO,SAAS,GAAG;AAEzB,QAAI,OAAO,WAAW,MAAM,GAAG,KAAK,OAAO,eAAe,OAAO,IAAI,GAAG;AACtE,WAAK,GAAG,IAAI,EAAE,GAAG,KAAK,SAAS,KAAK;AACpC;AAAA,IACF;AAEA,QAAI,OAAO,WAAW,UAAU,GAAG,KAAK,OAAO,eAAe,UAAU,IAAI,GAAG;AAC7E,WAAK,GAAG,IAAI,EAAE,GAAG,KAAK,aAAa,QAAQ,IAAI,aAAa,KAAK,WAAW,EAAE;AAC9E;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}