@botpress/cli 0.0.2

package/dist/init.js

@@ -0,0 +1,45 @@
+"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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+const DEFAULT_DIRNAME = ".botpress";
+const getOutDir = () => {
+  const { BP_OUTDIR } = process.env;
+  if (!BP_OUTDIR) {
+    return import_path.default.join(process.cwd(), DEFAULT_DIRNAME);
+  }
+  if (import_path.default.isAbsolute(BP_OUTDIR)) {
+    return BP_OUTDIR;
+  }
+  return import_path.default.join(process.cwd(), BP_OUTDIR);
+};
+const outDirPath = getOutDir();
+const outDirName = import_path.default.basename(outDirPath);
+const originalRequire = import_module.default.prototype.require;
+const rewire = function(mod) {
+  const importParts = mod.split("/");
+  if (importParts[0] === outDirName) {
+    const newMod = importParts.slice(1).join("/");
+    const fullpath = import_path.default.join(outDirPath, newMod);
+    return originalRequire.apply(this, [fullpath]);
+  }
+  return originalRequire.apply(this, [mod]);
+};
+import_module.default.prototype.require = rewire;

package/dist/init.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/init.ts"],
+  "sourcesContent": ["import Module from 'module'\nimport pathlib from 'path'\n\nconst DEFAULT_DIRNAME = '.botpress'\n\nconst getOutDir = () => {\n  const { BP_OUTDIR } = process.env\n  if (!BP_OUTDIR) {\n    return pathlib.join(process.cwd(), DEFAULT_DIRNAME)\n  }\n  if (pathlib.isAbsolute(BP_OUTDIR)) {\n    return BP_OUTDIR\n  }\n  return pathlib.join(process.cwd(), BP_OUTDIR)\n}\n\nconst outDirPath = getOutDir()\nconst outDirName = pathlib.basename(outDirPath)\nconst originalRequire = Module.prototype.require\n\nconst rewire = function (this: NodeRequire, mod: string) {\n  const importParts = mod.split('/')\n\n  if (importParts[0] === outDirName) {\n    const newMod = importParts.slice(1).join('/')\n    const fullpath = pathlib.join(outDirPath, newMod)\n    return originalRequire.apply(this, [fullpath])\n  }\n\n  return originalRequire.apply(this, [mod])\n} as NodeRequire\n\nModule.prototype.require = rewire\n"],
+  "mappings": "wdAAA,IAAAA,EAAmB,qBACnBC,EAAoB,mBAEdC,EAAkB,YAElBC,EAAY,IAAM,CACtB,GAAM,CAAE,UAAAC,CAAU,EAAI,QAAQ,IAC9B,OAAKA,EAGD,EAAAC,QAAQ,WAAWD,CAAS,EACvBA,EAEF,EAAAC,QAAQ,KAAK,QAAQ,IAAI,EAAGD,CAAS,EALnC,EAAAC,QAAQ,KAAK,QAAQ,IAAI,EAAGH,CAAe,CAMtD,EAEMI,EAAaH,EAAU,EACvBI,EAAa,EAAAF,QAAQ,SAASC,CAAU,EACxCE,EAAkB,EAAAC,QAAO,UAAU,QAEnCC,EAAS,SAA6BC,EAAa,CACvD,IAAMC,EAAcD,EAAI,MAAM,GAAG,EAEjC,GAAIC,EAAY,KAAOL,EAAY,CACjC,IAAMM,EAASD,EAAY,MAAM,CAAC,EAAE,KAAK,GAAG,EACtCE,EAAW,EAAAT,QAAQ,KAAKC,EAAYO,CAAM,EAChD,OAAOL,EAAgB,MAAM,KAAM,CAACM,CAAQ,CAAC,CAC/C,CAEA,OAAON,EAAgB,MAAM,KAAM,CAACG,CAAG,CAAC,CAC1C,EAEA,EAAAF,QAAO,UAAU,QAAUC",
+  "names": ["import_module", "import_path", "DEFAULT_DIRNAME", "getOutDir", "BP_OUTDIR", "pathlib", "outDirPath", "outDirName", "originalRequire", "Module", "rewire", "mod", "importParts", "newMod", "fullpath"]
+}

package/dist/logger/base-logger.js

@@ -0,0 +1,159 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_logger_exports = {};
+__export(base_logger_exports, {
+  BaseLogger: () => BaseLogger
+});
+module.exports = __toCommonJS(base_logger_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_lodash = __toESM(require("lodash"));
+var import_util = __toESM(require("util"));
+const DEFAULT_OPTIONS = { verbose: false };
+const NO_COLOR = (str) => str;
+const PINK = [255, 100, 255];
+const ORANGE = [255, 165, 0];
+const PURPLE = [128, 0, 128];
+const BG_COLORS = {
+  blue: import_chalk.default.bgBlueBright,
+  green: import_chalk.default.bgGreenBright,
+  yellow: import_chalk.default.bgYellowBright,
+  red: import_chalk.default.bgRedBright,
+  white: import_chalk.default.bgWhite,
+  pink: (str) => import_chalk.default.bgRgb(...PINK)(str),
+  orange: (str) => import_chalk.default.bgRgb(...ORANGE)(str),
+  purple: (str) => import_chalk.default.bgRgb(...PURPLE)(str)
+};
+const FG_COLORS = {
+  blue: import_chalk.default.blueBright,
+  green: import_chalk.default.green,
+  yellow: import_chalk.default.yellowBright,
+  red: import_chalk.default.red,
+  white: import_chalk.default.white,
+  pink: (str) => import_chalk.default.rgb(...PINK)(str),
+  orange: (str) => import_chalk.default.rgb(...ORANGE)(str),
+  purple: (str) => import_chalk.default.rgb(...PURPLE)(str)
+};
+const checkmark = {
+  default: "\u2713",
+  windows: "\u221A",
+  mac: "\u2714"
+};
+const cross = {
+  default: "\xD7",
+  mac: "\u2716"
+};
+const danger = { default: "\u26A0" };
+const circle = { default: "\u25CB" };
+const disc = { default: "\u25CF" };
+const space = { default: " " };
+const renderers = {
+  "\u2713": checkmark,
+  "\xD7": cross,
+  "\u26A0": danger,
+  "\u25CB": circle,
+  "\u25CF": disc,
+  " ": space
+};
+class BaseLogger {
+  opts;
+  constructor(opts = {}) {
+    this.opts = { ...DEFAULT_OPTIONS, ...opts };
+  }
+  log(message, props = {}) {
+    if (this.opts.json) {
+      return;
+    }
+    const prefix = this._resolvePrefix(props.prefix);
+    this.print(message, { ...props, prefix });
+  }
+  json(data, opts = { depth: Infinity }) {
+    if (this.opts.json) {
+      this.print(JSON.stringify(data, void 0, 2));
+      return;
+    }
+    const { depth } = opts;
+    const msg = import_util.default.inspect(data, { colors: true, depth });
+    this.print(msg);
+  }
+  debug(message, metadata) {
+    if (!this.opts.verbose || this.opts.json) {
+      return;
+    }
+    this.log(import_chalk.default.grey(message), { metadata, prefix: { symbol: "\u25CF", fg: "blue" } });
+  }
+  started(message, metadata) {
+    if (this.opts.json) {
+      return;
+    }
+    this.log(message, { metadata, prefix: { symbol: "\u25CB", fg: "purple" } });
+  }
+  success(message, metadata) {
+    if (this.opts.json) {
+      return;
+    }
+    this.log(message, { metadata, prefix: { symbol: "\u2713", fg: "green" } });
+  }
+  warn(message, metadata) {
+    if (this.opts.json) {
+      return;
+    }
+    this.log(message, { metadata, prefix: { symbol: "\u26A0", fg: "yellow" } });
+  }
+  error(message, metadata) {
+    if (this.opts.json) {
+      return;
+    }
+    this.log(message, { metadata, prefix: { symbol: "\xD7", fg: "red" } });
+  }
+  _resolvePrefix(prefix) {
+    if (!prefix) {
+      return;
+    }
+    if (import_lodash.default.isString(prefix)) {
+      return prefix;
+    }
+    const { symbol, fg, bg, indent } = prefix;
+    const renderedSymbol = this._renderSymbol(symbol);
+    const fgcolor = fg ? FG_COLORS[fg] : NO_COLOR;
+    const bgcolor = bg ? BG_COLORS[bg] : NO_COLOR;
+    const indentStr = indent ? " ".repeat(indent) : "";
+    const symbolStr = fgcolor(bgcolor(renderedSymbol));
+    return `${indentStr}${symbolStr}`;
+  }
+  _renderSymbol(symbol) {
+    const renderer = renderers[symbol];
+    if (process.platform === "win32") {
+      return renderer.windows || renderer.default;
+    } else if (process.platform === "darwin") {
+      return renderer.mac || renderer.default;
+    } else {
+      return renderer.default;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseLogger
+});

package/dist/logger/index.js

@@ -0,0 +1,79 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  Logger: () => Logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_readline = require("readline");
+var import_base_logger = require("./base-logger");
+class Logger extends import_base_logger.BaseLogger {
+  _previousLine;
+  print(message, props = {}) {
+    this.cleanup();
+    const { metadata, prefix } = props;
+    if (prefix) {
+      console.log(prefix, message, metadata ?? "");
+      return;
+    }
+    console.log(message, metadata ?? "");
+  }
+  line() {
+    this.cleanup();
+    const currentLine = new SingleLineLogger({ ...this.opts });
+    this._previousLine = currentLine;
+    return currentLine;
+  }
+  cleanup() {
+    if (this._previousLine) {
+      this._previousLine.commit();
+      this._previousLine = void 0;
+    }
+  }
+}
+class SingleLineLogger extends import_base_logger.BaseLogger {
+  _commited = false;
+  constructor(opts) {
+    super(opts);
+  }
+  commit() {
+    if (this._commited) {
+      return;
+    }
+    this._commited = true;
+    console.log();
+  }
+  print(message, props = {}) {
+    if (this._commited) {
+      return;
+    }
+    (0, import_readline.clearLine)(process.stdout, 0);
+    const { metadata, prefix } = props;
+    (0, import_readline.cursorTo)(process.stdout, 0);
+    if (prefix) {
+      process.stdout.write(`${prefix} ${message} ${metadata ?? ""}`);
+      return;
+    }
+    process.stdout.write(`${message} ${metadata ?? ""}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger
+});

package/dist/paths.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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paths_exports = {};
+__export(paths_exports, {
+  absoluteFrom: () => absoluteFrom,
+  cwd: () => cwd,
+  isAbsolute: () => isAbsolute,
+  isPath: () => isPath,
+  relativeFrom: () => relativeFrom,
+  rmExtension: () => rmExtension,
+  toUnix: () => toUnix
+});
+module.exports = __toCommonJS(paths_exports);
+var import_path = __toESM(require("path"));
+const cwd = () => process.cwd();
+const isAbsolute = (path) => import_path.default.isAbsolute(path);
+const isPath = (path) => isAbsolute(path) || path.startsWith(".");
+const rmExtension = (filename) => filename.replace(/\.[^/.]+$/, "");
+const toUnix = (path) => path.split(import_path.default.sep).join(import_path.default.posix.sep);
+const absoluteFrom = (rootdir, target) => {
+  if (isAbsolute(target)) {
+    return target;
+  }
+  return import_path.default.join(rootdir, target);
+};
+const relativeFrom = (rootdir, target) => {
+  let absPath;
+  if (isAbsolute(target)) {
+    absPath = target;
+  } else {
+    absPath = import_path.default.resolve(import_path.default.join(rootdir, target));
+  }
+  if (!absPath.startsWith(rootdir)) {
+    return target;
+  }
+  return absPath.slice(rootdir.length + 1);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  absoluteFrom,
+  cwd,
+  isAbsolute,
+  isPath,
+  relativeFrom,
+  rmExtension,
+  toUnix
+});

package/dist/requires.js

@@ -0,0 +1,49 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requires_exports = {};
+__export(requires_exports, {
+  requireJsCode: () => requireJsCode,
+  requireJsFile: () => requireJsFile
+});
+module.exports = __toCommonJS(requires_exports);
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+const requireJsFile = (path) => {
+  return require(path);
+};
+const requireJsCode = (code) => {
+  const filedir = "tmp";
+  const filename = `${Date.now()}.js`;
+  const fileid = import_path.default.join(filedir, filename);
+  const m = new import_module.default(fileid);
+  m.filename = filename;
+  m._compile(code, filename);
+  return m.exports;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requireJsCode,
+  requireJsFile
+});

package/dist/type-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 type_utils_exports = {};
+module.exports = __toCommonJS(type_utils_exports);

package/dist/worker/child-entrypoint.js

@@ -0,0 +1,61 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var child_entrypoint_exports = {};
+__export(child_entrypoint_exports, {
+  ENTRY_POINT: () => ENTRY_POINT
+});
+module.exports = __toCommonJS(child_entrypoint_exports);
+var import_readline = __toESM(require("readline"));
+var requireutils = __toESM(require("../requires"));
+var import_config = require("./config");
+var import_is_child = require("./is-child");
+const ENTRY_POINT = __filename;
+const childProcessEntrypoint = async (_props) => {
+  const config = (0, import_config.getConfigFromEnv)();
+  import_readline.default.emitKeypressEvents(process.stdin);
+  process.stdin.on("keypress", (_, key) => {
+    if (key && key.ctrl && key.name === "c") {
+      process.exit(0);
+    }
+    if (key && key.name === "escape") {
+      process.exit(0);
+    }
+  });
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  if (config.type === "code") {
+    await requireutils.requireJsCode(config.code);
+  }
+  if (config.type === "file") {
+    await requireutils.requireJsFile(config.file);
+  }
+};
+if (import_is_child.processProps.type === "child") {
+  void childProcessEntrypoint(import_is_child.processProps);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTRY_POINT
+});

package/dist/worker/config.js

@@ -0,0 +1,58 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_ENV_KEY: () => CONFIG_ENV_KEY,
+  configSchema: () => configSchema,
+  getConfigFromEnv: () => getConfigFromEnv
+});
+module.exports = __toCommonJS(config_exports);
+var import_zod = __toESM(require("zod"));
+const CONFIG_ENV_KEY = "CHILD_PROCESS_CONFIGURATION";
+const configSchema = import_zod.default.union([
+  import_zod.default.object({
+    type: import_zod.default.literal("code"),
+    code: import_zod.default.string(),
+    env: import_zod.default.record(import_zod.default.string(), import_zod.default.string()).optional()
+  }),
+  import_zod.default.object({
+    type: import_zod.default.literal("file"),
+    file: import_zod.default.string(),
+    env: import_zod.default.record(import_zod.default.string(), import_zod.default.string()).optional()
+  })
+]);
+const getConfigFromEnv = () => {
+  const config = process.env[CONFIG_ENV_KEY];
+  if (!config) {
+    throw new Error(`Config variable ${CONFIG_ENV_KEY} was not set`);
+  }
+  return configSchema.parse(JSON.parse(config));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_ENV_KEY,
+  configSchema,
+  getConfigFromEnv
+});

package/dist/worker/index.js

@@ -0,0 +1,55 @@
+"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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var worker_exports = {};
+__export(worker_exports, {
+  Config: () => import_config2.Config,
+  spawnChildProcess: () => spawnChildProcess
+});
+module.exports = __toCommonJS(worker_exports);
+var childProcess = __toESM(require("child_process"));
+var import_child_entrypoint = require("./child-entrypoint");
+var import_config = require("./config");
+var import_is_child = require("./is-child");
+var import_listen_child = require("./listen-child");
+var import_config2 = require("./config");
+const spawnChildProcess = async (config, logger) => {
+  if (import_is_child.isChildProcess) {
+    throw new Error("Cannot spawn child process from child process");
+  }
+  const child = childProcess.fork(import_child_entrypoint.ENTRY_POINT, [], {
+    stdio: "inherit",
+    env: {
+      [import_is_child.CHILD_ENV_KEY]: import_is_child.CHILD_ENV_VALUE,
+      [import_config.CONFIG_ENV_KEY]: JSON.stringify(config),
+      ...config.env
+    }
+  });
+  return (0, import_listen_child.listenChild)(child, logger);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  spawnChildProcess
+});

package/dist/worker/is-child.js

@@ -0,0 +1,52 @@
+"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 is_child_exports = {};
+__export(is_child_exports, {
+  CHILD_ENV_KEY: () => CHILD_ENV_KEY,
+  CHILD_ENV_VALUE: () => CHILD_ENV_VALUE,
+  isChildProcess: () => isChildProcess,
+  processProps: () => processProps
+});
+module.exports = __toCommonJS(is_child_exports);
+const CHILD_ENV_KEY = "IS_CHILD";
+const CHILD_ENV_VALUE = "true";
+const getProcessProps = () => {
+  const type = process.env[CHILD_ENV_KEY] === CHILD_ENV_VALUE ? "child" : "main";
+  if (type === "main") {
+    return {
+      type
+    };
+  }
+  if (!process.send) {
+    throw new Error(`Please do not use variable ${CHILD_ENV_KEY} manually`);
+  }
+  return {
+    type,
+    sendMessage: process.send
+  };
+};
+const processProps = getProcessProps();
+const isChildProcess = processProps.type === "child";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHILD_ENV_KEY,
+  CHILD_ENV_VALUE,
+  isChildProcess,
+  processProps
+});