@automattic/vip 4.1.6 → 4.1.8

package/dist/lib/edge-workers/toolchains/assemblyscript/templates.js

@@ -1,44 +1,42 @@
 "use strict";
-
-exports.__esModule = true;
-exports.TSCONFIG_JSON = exports.README = exports.PACKAGE_JSON = exports.GITIGNORE = void 0;
-exports.starterWorker = starterWorker;
-var _constants = require("./constants");
-var _project = require("../../project");
 /**
  * The files written into a scaffolded AssemblyScript project. Kept out of the
  * toolchain logic so the scaffold steps read cleanly; the dynamic bits (SDK
  * package name, workers dir, default entry) interpolate from shared constants so
  * there's a single source of truth.
  */
-
-const PACKAGE_JSON = exports.PACKAGE_JSON = {
-  name: 'edge-workers',
-  version: '0.0.0',
-  private: true,
-  description: 'VIP edge workers',
-  type: 'module',
-  scripts: {
-    build: 'vip edge-workers build --all'
-  },
-  dependencies: {
-    [_constants.SDK_PACKAGE]: _constants.SDK_VERSION
-  },
-  devDependencies: {
-    assemblyscript: _constants.ASSEMBLYSCRIPT_VERSION
-  }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.README = exports.GITIGNORE = exports.TSCONFIG_JSON = exports.PACKAGE_JSON = void 0;
+exports.starterWorker = starterWorker;
+const constants_1 = require("./constants");
+const project_1 = require("../../project");
+exports.PACKAGE_JSON = {
+    name: 'edge-workers',
+    version: '0.0.0',
+    private: true,
+    description: 'VIP edge workers',
+    type: 'module',
+    scripts: {
+        build: 'vip edge-workers build --all',
+    },
+    dependencies: {
+        [constants_1.SDK_PACKAGE]: constants_1.SDK_VERSION,
+    },
+    devDependencies: {
+        assemblyscript: constants_1.ASSEMBLYSCRIPT_VERSION,
+    },
 };
-const TSCONFIG_JSON = exports.TSCONFIG_JSON = {
-  extends: 'assemblyscript/std/assembly.json',
-  include: ['./**/*.ts']
+exports.TSCONFIG_JSON = {
+    extends: 'assemblyscript/std/assembly.json',
+    include: ['./**/*.ts'],
 };
-const GITIGNORE = exports.GITIGNORE = `node_modules/
-${_project.BUILD_DIR}/
+exports.GITIGNORE = `node_modules/
+${project_1.BUILD_DIR}/
 `;
-const README = exports.README = `# Edge workers
+exports.README = `# Edge workers
 
 AssemblyScript edge workers for your VIP environment. Each worker lives in its
-own folder under \`${_project.WORKERS_DIR}/\` and is compiled to a \`.wasm\` binary that
+own folder under \`${project_1.WORKERS_DIR}/\` and is compiled to a \`.wasm\` binary that
 runs at the edge.
 
 ## Getting started
@@ -46,7 +44,7 @@ runs at the edge.
 \`\`\`sh
 npm install                       # install the SDK + compiler
 vip edge-workers new my-worker    # scaffold a new worker
-# edit ${_project.WORKERS_DIR}/my-worker/${_constants.DEFAULT_ENTRY}
+# edit ${project_1.WORKERS_DIR}/my-worker/${constants_1.DEFAULT_ENTRY}
 vip @my-site.develop edge-workers deploy my-worker
 \`\`\`
 
@@ -62,9 +60,9 @@ To work with JSON in a worker, install [json-as](https://www.npmjs.com/package/j
 transform automatically when the package is present.
 `;
 function starterWorker() {
-  return `import { Response, onClientResponse } from '${_constants.SDK_PACKAGE}';
+    return `import { Response, onClientResponse } from '${constants_1.SDK_PACKAGE}';
 
-export { alloc, on_client_response } from '${_constants.SDK_PACKAGE}/assembly/index';
+export { alloc, on_client_response } from '${constants_1.SDK_PACKAGE}/assembly/index';
 
 // Client response: runs before the response reaches the client.
 onClientResponse( ( response: Response ): void => {} );
@@ -82,4 +80,4 @@ onClientResponse( ( response: Response ): void => {} );
 // Origin response: Response, onOriginResponse, on_origin_response
 // onOriginResponse( ( response: Response ): void => {} );
 `;
-}
+}

package/dist/lib/edge-workers/toolchains/index.js

@@ -1,11 +1,4 @@
 "use strict";
-
-exports.__esModule = true;
-exports.getToolchain = getToolchain;
-var _userError = _interopRequireDefault(require("../../user-error"));
-var _types = require("../types");
-var _assemblyscript = _interopRequireDefault(require("./assemblyscript"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Toolchain registry.
  *
@@ -17,14 +10,21 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * is language-neutral, so adding a new language (e.g. Rust) means implementing
  * one Toolchain and registering it here — nothing in the command layer changes.
  */
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolchain = getToolchain;
+const user_error_1 = __importDefault(require("../../user-error"));
+const types_1 = require("../types");
+const assemblyscript_1 = __importDefault(require("./assemblyscript"));
 const TOOLCHAINS = {
-  assemblyscript: _assemblyscript.default
+    assemblyscript: assemblyscript_1.default,
 };
 function getToolchain(type) {
-  const toolchain = TOOLCHAINS[type];
-  if (!toolchain) {
-    throw new _userError.default(`Unknown edge worker type "${type}". Supported types: ${_types.SUPPORTED_EDGE_WORKER_TYPES.join(', ')}.`);
-  }
-  return toolchain;
-}
+    const toolchain = TOOLCHAINS[type];
+    if (!toolchain) {
+        throw new user_error_1.default(`Unknown edge worker type "${type}". Supported types: ${types_1.SUPPORTED_EDGE_WORKER_TYPES.join(', ')}.`);
+    }
+    return toolchain;
+}

package/dist/lib/edge-workers/types.js

@@ -1,7 +1,4 @@
 "use strict";
-
-exports.__esModule = true;
-exports.SUPPORTED_EDGE_WORKER_TYPES = exports.EDGE_WORKER_LOCATION_OPERATORS = exports.DEFAULT_EDGE_WORKER_TYPE = void 0;
 /**
  * Shared types for the edge-workers commands.
  *
@@ -9,38 +6,13 @@ exports.SUPPORTED_EDGE_WORKER_TYPES = exports.EDGE_WORKER_LOCATION_OPERATORS = e
  * lives behind the Toolchain abstraction; the remote half (upload, list, toggle)
  * is language-neutral because the deployable artifact is always a `.wasm` binary.
  */
-
-/**
- * The languages/SDKs an edge-workers project can be scaffolded with. Only
- * AssemblyScript is implemented today; new toolchains slot in via the registry
- * in `./toolchains` without touching the command layer.
- */
-
-const SUPPORTED_EDGE_WORKER_TYPES = exports.SUPPORTED_EDGE_WORKER_TYPES = ['assemblyscript'];
-const DEFAULT_EDGE_WORKER_TYPE = exports.DEFAULT_EDGE_WORKER_TYPE = 'assemblyscript';
-
-/** The behavior to apply when a worker errors at runtime (mirrors the API enum). */
-
-/** The request/response phases a worker hooks into, derived from its wasm exports (mirrors the API enum). */
-
-/** The operators available for matching an edge worker's location (mirrors the API enum). */
-
-const EDGE_WORKER_LOCATION_OPERATORS = exports.EDGE_WORKER_LOCATION_OPERATORS = ['contains', 'equals', 'starts_with', 'ends_with'];
-
-/** A rule scoping which requests a worker runs on. Runs on all requests when absent. */
-
-/**
- * The project descriptor written once at `init` to the project root
- * (`edge-workers.json`). It records which toolchain the project uses so that
- * `new`/`build`/`deploy` can dispatch without re-asking. It is intentionally NOT
- * a registry of workers — workers are discovered by scanning for `worker.json`.
- */
-
-/**
- * The per-worker manifest (`worker.json`) co-located with each worker's code.
- * Holds exactly the metadata the create/update API needs, keyed by `name`.
- */
-
-/** A worker discovered on disk: its directory plus parsed manifest. */
-
-/** A deployed edge worker as returned by the API. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_WORKER_LOCATION_OPERATORS = exports.DEFAULT_EDGE_WORKER_TYPE = exports.SUPPORTED_EDGE_WORKER_TYPES = void 0;
+exports.SUPPORTED_EDGE_WORKER_TYPES = ['assemblyscript'];
+exports.DEFAULT_EDGE_WORKER_TYPE = 'assemblyscript';
+exports.EDGE_WORKER_LOCATION_OPERATORS = [
+    'contains',
+    'equals',
+    'starts_with',
+    'ends_with',
+];

package/dist/lib/edge-workers/validation.js

@@ -1,191 +1,202 @@
 "use strict";
-
-exports.__esModule = true;
-exports.parseProjectDescriptor = parseProjectDescriptor;
-exports.parseWorkerManifest = parseWorkerManifest;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkerName = validateWorkerName;
+exports.resolvePathWithin = resolvePathWithin;
 exports.resolveExistingPathWithin = resolveExistingPathWithin;
 exports.resolveOutputPathWithin = resolveOutputPathWithin;
-exports.resolvePathWithin = resolvePathWithin;
-exports.validateWorkerName = validateWorkerName;
-var _nodeFs = _interopRequireDefault(require("node:fs"));
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _userError = _interopRequireDefault(require("../user-error"));
-var _output = require("./output");
-var _types = require("./types");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+exports.parseProjectDescriptor = parseProjectDescriptor;
+exports.parseWorkerManifest = parseWorkerManifest;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const user_error_1 = __importDefault(require("../user-error"));
+const output_1 = require("./output");
+const types_1 = require("./types");
 // eslint-disable-next-line security/detect-unsafe-regex
 const WINDOWS_RESERVED_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
 // This range deliberately rejects every Windows-disallowed control character.
 // eslint-disable-next-line no-control-regex
 const INVALID_PATH_CHARACTER = /[<>:"/\\|?*\u0000-\u001f]/;
 function validateWorkerName(name, label = 'worker name') {
-  if (typeof name !== 'string' || name.length === 0 || name.length > 64 || name === '.' || name === '..' || INVALID_PATH_CHARACTER.test(name) || /[. ]$/.test(name) || WINDOWS_RESERVED_NAME.test(name)) {
-    throw new _userError.default(`Invalid ${label} "${String(name)}".`);
-  }
-  return name;
+    if (typeof name !== 'string' ||
+        name.length === 0 ||
+        name.length > 64 ||
+        name === '.' ||
+        name === '..' ||
+        INVALID_PATH_CHARACTER.test(name) ||
+        /[. ]$/.test(name) ||
+        WINDOWS_RESERVED_NAME.test(name)) {
+        throw new user_error_1.default(`Invalid ${label} "${String(name)}".`);
+    }
+    return name;
 }
 function resolvePathWithin(root, relativePath, label) {
-  if (typeof relativePath !== 'string' || relativePath.length === 0 || _nodePath.default.isAbsolute(relativePath)) {
-    throw new _userError.default(`${label} must be a non-empty relative path.`);
-  }
-  const resolvedRoot = _nodePath.default.resolve(root);
-  const resolvedPath = _nodePath.default.resolve(resolvedRoot, relativePath);
-  const relative = _nodePath.default.relative(resolvedRoot, resolvedPath);
-  if (relative === '..' || relative.startsWith(`..${_nodePath.default.sep}`) || _nodePath.default.isAbsolute(relative)) {
-    throw new _userError.default(`${label} must stay within "${resolvedRoot}".`);
-  }
-  return resolvedPath;
+    if (typeof relativePath !== 'string' ||
+        relativePath.length === 0 ||
+        node_path_1.default.isAbsolute(relativePath)) {
+        throw new user_error_1.default(`${label} must be a non-empty relative path.`);
+    }
+    const resolvedRoot = node_path_1.default.resolve(root);
+    const resolvedPath = node_path_1.default.resolve(resolvedRoot, relativePath);
+    const relative = node_path_1.default.relative(resolvedRoot, resolvedPath);
+    if (relative === '..' ||
+        relative.startsWith(`..${node_path_1.default.sep}`) ||
+        node_path_1.default.isAbsolute(relative)) {
+        throw new user_error_1.default(`${label} must stay within "${resolvedRoot}".`);
+    }
+    return resolvedPath;
 }
 function isPathWithin(root, candidate) {
-  const relative = _nodePath.default.relative(root, candidate);
-  return relative === '' || relative !== '..' && !relative.startsWith(`..${_nodePath.default.sep}`) && !_nodePath.default.isAbsolute(relative);
+    const relative = node_path_1.default.relative(root, candidate);
+    return (relative === '' ||
+        (relative !== '..' &&
+            !relative.startsWith(`..${node_path_1.default.sep}`) &&
+            !node_path_1.default.isAbsolute(relative)));
 }
 function realpath(target, label) {
-  try {
-    return _nodeFs.default.realpathSync.native(target);
-  } catch {
-    throw new _userError.default(`${label} could not be resolved at "${target}".`);
-  }
+    try {
+        return node_fs_1.default.realpathSync.native(target);
+    }
+    catch {
+        throw new user_error_1.default(`${label} could not be resolved at "${target}".`);
+    }
 }
 function lstatIfExists(target) {
-  try {
-    return _nodeFs.default.lstatSync(target);
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return undefined;
-    }
-    throw error;
-  }
+    try {
+        return node_fs_1.default.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
 }
 function assertCanonicalPathWithin(root, candidate, label) {
-  if (!isPathWithin(root, candidate)) {
-    throw new _userError.default(`${label} must stay within "${root}".`);
-  }
+    if (!isPathWithin(root, candidate)) {
+        throw new user_error_1.default(`${label} must stay within "${root}".`);
+    }
 }
 function ensureOutputDirectory(target, label) {
-  const stat = lstatIfExists(target);
-  if (!stat) {
-    _nodeFs.default.mkdirSync(target);
-    return;
-  }
-  if (stat.isSymbolicLink()) {
-    throw new _userError.default(`${label} must not be a symbolic link.`);
-  }
-  if (!stat.isDirectory()) {
-    throw new _userError.default(`${label} must be a directory.`);
-  }
+    const stat = lstatIfExists(target);
+    if (!stat) {
+        node_fs_1.default.mkdirSync(target);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        throw new user_error_1.default(`${label} must not be a symbolic link.`);
+    }
+    if (!stat.isDirectory()) {
+        throw new user_error_1.default(`${label} must be a directory.`);
+    }
 }
 function validateExistingOutput(outputPath, canonicalRoot, label) {
-  const stat = lstatIfExists(outputPath);
-  if (!stat) {
-    return;
-  }
-  if (stat.isSymbolicLink()) {
-    throw new _userError.default(`${label} must not be a symbolic link.`);
-  }
-  if (!stat.isFile()) {
-    throw new _userError.default(`${label} must be a regular file.`);
-  }
-  assertCanonicalPathWithin(canonicalRoot, realpath(outputPath, label), label);
+    const stat = lstatIfExists(outputPath);
+    if (!stat) {
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        throw new user_error_1.default(`${label} must not be a symbolic link.`);
+    }
+    if (!stat.isFile()) {
+        throw new user_error_1.default(`${label} must be a regular file.`);
+    }
+    assertCanonicalPathWithin(canonicalRoot, realpath(outputPath, label), label);
 }
-
 /** Resolve an existing input and require its canonical target to remain below the canonical root. */
 function resolveExistingPathWithin(root, relativePath, label) {
-  const resolvedPath = resolvePathWithin(root, relativePath, label);
-  const canonicalRoot = realpath(_nodePath.default.resolve(root), `${label} root`);
-  const canonicalPath = realpath(resolvedPath, label);
-  if (!isPathWithin(canonicalRoot, canonicalPath)) {
-    throw new _userError.default(`${label} must stay within "${canonicalRoot}".`);
-  }
-  return canonicalPath;
+    const resolvedPath = resolvePathWithin(root, relativePath, label);
+    const canonicalRoot = realpath(node_path_1.default.resolve(root), `${label} root`);
+    const canonicalPath = realpath(resolvedPath, label);
+    if (!isPathWithin(canonicalRoot, canonicalPath)) {
+        throw new user_error_1.default(`${label} must stay within "${canonicalRoot}".`);
+    }
+    return canonicalPath;
 }
-
 /**
  * Prepare an output path below an existing root. Existing parent components and
  * the output itself must not be symlinks. Missing parents are created one at a
  * time and then canonicalized below the root before the path is returned.
  */
 function resolveOutputPathWithin(root, relativePath, label, directoryLabel) {
-  const resolvedRoot = _nodePath.default.resolve(root);
-  const resolvedPath = resolvePathWithin(resolvedRoot, relativePath, label);
-  const canonicalRoot = realpath(resolvedRoot, `${label} root`);
-  const relativeParent = _nodePath.default.relative(resolvedRoot, _nodePath.default.dirname(resolvedPath));
-  const components = relativeParent === '' ? [] : relativeParent.split(_nodePath.default.sep);
-  let current = resolvedRoot;
-  for (const component of components) {
-    current = _nodePath.default.join(current, component);
-    ensureOutputDirectory(current, directoryLabel);
-    assertCanonicalPathWithin(canonicalRoot, realpath(current, directoryLabel), directoryLabel);
-  }
-  const canonicalParent = realpath(_nodePath.default.dirname(resolvedPath), directoryLabel);
-  const outputPath = _nodePath.default.join(canonicalParent, _nodePath.default.basename(resolvedPath));
-  validateExistingOutput(outputPath, canonicalRoot, label);
-  return outputPath;
+    const resolvedRoot = node_path_1.default.resolve(root);
+    const resolvedPath = resolvePathWithin(resolvedRoot, relativePath, label);
+    const canonicalRoot = realpath(resolvedRoot, `${label} root`);
+    const relativeParent = node_path_1.default.relative(resolvedRoot, node_path_1.default.dirname(resolvedPath));
+    const components = relativeParent === '' ? [] : relativeParent.split(node_path_1.default.sep);
+    let current = resolvedRoot;
+    for (const component of components) {
+        current = node_path_1.default.join(current, component);
+        ensureOutputDirectory(current, directoryLabel);
+        assertCanonicalPathWithin(canonicalRoot, realpath(current, directoryLabel), directoryLabel);
+    }
+    const canonicalParent = realpath(node_path_1.default.dirname(resolvedPath), directoryLabel);
+    const outputPath = node_path_1.default.join(canonicalParent, node_path_1.default.basename(resolvedPath));
+    validateExistingOutput(outputPath, canonicalRoot, label);
+    return outputPath;
 }
 function isPlainObject(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function parseProjectDescriptor(value, file) {
-  if (!isPlainObject(value)) {
-    throw new _userError.default(`Project descriptor at "${file}" has an invalid "type" field.`);
-  }
-  if (value.type === undefined) {
-    throw new _userError.default(`Project descriptor at "${file}" is missing a "type" field.`);
-  }
-  if (!_types.SUPPORTED_EDGE_WORKER_TYPES.includes(value.type)) {
-    throw new _userError.default(`Project descriptor at "${file}" has an invalid "type" field.`);
-  }
-  if (value.sdk !== undefined && typeof value.sdk !== 'string') {
-    throw new _userError.default(`Project descriptor at "${file}" has an invalid "sdk" field.`);
-  }
-  const descriptor = {
-    type: value.type
-  };
-  if (value.sdk !== undefined) {
-    descriptor.sdk = value.sdk;
-  }
-  return descriptor;
+    if (!isPlainObject(value)) {
+        throw new user_error_1.default(`Project descriptor at "${file}" has an invalid "type" field.`);
+    }
+    if (value.type === undefined) {
+        throw new user_error_1.default(`Project descriptor at "${file}" is missing a "type" field.`);
+    }
+    if (!types_1.SUPPORTED_EDGE_WORKER_TYPES.includes(value.type)) {
+        throw new user_error_1.default(`Project descriptor at "${file}" has an invalid "type" field.`);
+    }
+    if (value.sdk !== undefined && typeof value.sdk !== 'string') {
+        throw new user_error_1.default(`Project descriptor at "${file}" has an invalid "sdk" field.`);
+    }
+    const descriptor = { type: value.type };
+    if (value.sdk !== undefined) {
+        descriptor.sdk = value.sdk;
+    }
+    return descriptor;
 }
 function parseLocation(value, file) {
-  if (value === undefined || value === null) {
-    return value;
-  }
-  if (!isPlainObject(value)) {
-    throw new _userError.default(`Worker manifest at "${file}" has an invalid location.`);
-  }
-  if (!_types.EDGE_WORKER_LOCATION_OPERATORS.includes(value.operator)) {
-    throw new _userError.default(`Worker manifest at "${file}" has an invalid location operator.`);
-  }
-  if (typeof value.value !== 'string' || value.value.length === 0 || (0, _output.hasTerminalControlCharacters)(value.value)) {
-    throw new _userError.default(`Worker manifest at "${file}" has an invalid location value.`);
-  }
-  return {
-    operator: value.operator,
-    value: value.value
-  };
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (!isPlainObject(value)) {
+        throw new user_error_1.default(`Worker manifest at "${file}" has an invalid location.`);
+    }
+    if (!types_1.EDGE_WORKER_LOCATION_OPERATORS.includes(value.operator)) {
+        throw new user_error_1.default(`Worker manifest at "${file}" has an invalid location operator.`);
+    }
+    if (typeof value.value !== 'string' ||
+        value.value.length === 0 ||
+        (0, output_1.hasTerminalControlCharacters)(value.value)) {
+        throw new user_error_1.default(`Worker manifest at "${file}" has an invalid location value.`);
+    }
+    return { operator: value.operator, value: value.value };
 }
 function parseWorkerManifest(value, file) {
-  if (!isPlainObject(value)) {
-    throw new _userError.default(`Worker manifest at "${file}" must be an object.`);
-  }
-  const name = validateWorkerName(value.name, 'worker name');
-  if (typeof value.entry !== 'string' || value.entry.length === 0) {
-    throw new _userError.default(`Worker manifest at "${file}" is missing an "entry" field.`);
-  }
-  resolvePathWithin(_nodePath.default.dirname(file), value.entry, 'Worker entry');
-  if (value.on_failure !== undefined && value.on_failure !== 'continue' && value.on_failure !== 'error') {
-    throw new _userError.default(`Worker manifest at "${file}" has an invalid "on_failure" field.`);
-  }
-  const manifest = {
-    name,
-    entry: value.entry
-  };
-  const location = parseLocation(value.location, file);
-  if (location !== undefined) {
-    manifest.location = location;
-  }
-  if (value.on_failure !== undefined) {
-    manifest.on_failure = value.on_failure;
-  }
-  return manifest;
-}
+    if (!isPlainObject(value)) {
+        throw new user_error_1.default(`Worker manifest at "${file}" must be an object.`);
+    }
+    const name = validateWorkerName(value.name, 'worker name');
+    if (typeof value.entry !== 'string' || value.entry.length === 0) {
+        throw new user_error_1.default(`Worker manifest at "${file}" is missing an "entry" field.`);
+    }
+    resolvePathWithin(node_path_1.default.dirname(file), value.entry, 'Worker entry');
+    if (value.on_failure !== undefined &&
+        value.on_failure !== 'continue' &&
+        value.on_failure !== 'error') {
+        throw new user_error_1.default(`Worker manifest at "${file}" has an invalid "on_failure" field.`);
+    }
+    const manifest = { name, entry: value.entry };
+    const location = parseLocation(value.location, file);
+    if (location !== undefined) {
+        manifest.location = location;
+    }
+    if (value.on_failure !== undefined) {
+        manifest.on_failure = value.on_failure;
+    }
+    return manifest;
+}

package/dist/lib/env.js

@@ -1,26 +1,25 @@
 "use strict";
-
-exports.__esModule = true;
-exports.default = void 0;
-var _nodeOs = require("node:os");
-var _package = _interopRequireDefault(require("../../package.json"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_os_1 = require("node:os");
+const package_json_1 = __importDefault(require("../../package.json"));
 const app = {
-  name: _package.default.name,
-  version: _package.default.version
+    version: package_json_1.default.version,
 };
 const os = {
-  name: (0, _nodeOs.platform)(),
-  version: (0, _nodeOs.release)(),
-  arch: (0, _nodeOs.arch)()
+    name: (0, node_os_1.platform)(),
+    version: (0, node_os_1.release)(),
+    arch: (0, node_os_1.arch)(),
 };
 const node = {
-  version: process.version
+    version: process.version,
 };
 const env = {
-  app,
-  os,
-  node,
-  userAgent: `vip-cli/${app.version} (node/${node.version}; ${os.name}/${os.version}; +https://wpvip.com)`
+    app,
+    os,
+    node,
+    userAgent: `vip-cli/${app.version} (node/${node.version}; ${os.name}/${os.version}; +https://wpvip.com)`,
 };
-var _default = exports.default = env;
+exports.default = env;

package/dist/lib/envvar/api-delete.js

@@ -1,11 +1,12 @@
 "use strict";
-
-exports.__esModule = true;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = deleteEnvVar;
-var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
-var _api = _interopRequireDefault(require("../../lib/api"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const mutation = (0, _graphqlTag.default)`
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+const api_1 = __importDefault(require("../../lib/api"));
+const mutation = (0, graphql_tag_1.default) `
 	mutation DeleteEnvironmentVariable(
 		$appId: Int!
 		$envId: Int!
@@ -31,15 +32,12 @@ const mutation = (0, _graphqlTag.default)`
 	}
 `;
 async function deleteEnvVar(appId, envId, name, reloadManifest = false) {
-  const api = (0, _api.default)();
-  const variables = {
-    appId,
-    envId,
-    name,
-    reloadManifest
-  };
-  return api.mutate({
-    mutation,
-    variables
-  });
-}
+    const api = (0, api_1.default)();
+    const variables = {
+        appId,
+        envId,
+        name,
+        reloadManifest,
+    };
+    return api.mutate({ mutation, variables });
+}