@kizenapps/packager 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  API_NAME_PATTERN: () => API_NAME_PATTERN,
   AUTOMATION_SCRIPT_FILE: () => AUTOMATION_SCRIPT_FILE,
   AUTOMATION_STEPS_DIRECTORY_NAME: () => AUTOMATION_STEPS_DIRECTORY_NAME,
   BLOCKS_DIRECTORY_NAME: () => BLOCKS_DIRECTORY_NAME,
@@ -40,6 +41,8 @@ __export(index_exports, {
   CRYPTO_ALG: () => CRYPTO_ALG,
   CRYPTO_VERSION: () => CRYPTO_VERSION,
   DATA_ADORNMENTS_DIRECTORY_NAME: () => DATA_ADORNMENTS_DIRECTORY_NAME,
+  ENVIRONMENTS: () => ENVIRONMENTS,
+  ENVIRONMENT_ALIASES: () => ENVIRONMENT_ALIASES,
   EVENT_SCRIPTS_DIRECTORY_NAME: () => EVENT_SCRIPTS_DIRECTORY_NAME,
   FLOATING_FRAMES_DIRECTORY_NAME: () => FLOATING_FRAMES_DIRECTORY_NAME,
   JS_ACTIONS_DIRECTORY_NAME: () => JS_ACTIONS_DIRECTORY_NAME,
@@ -48,6 +51,8 @@ __export(index_exports, {
   MANIFEST_FILE_NAME: () => MANIFEST_FILE_NAME,
   MESSAGE_SCRIPT_FILE: () => MESSAGE_SCRIPT_FILE,
   OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME: () => OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME,
+  PUBLISHABLE_ENVIRONMENTS: () => PUBLISHABLE_ENVIRONMENTS,
+  PluginValidationError: () => PluginValidationError,
   RELEASE_NOTES_EXTENSION: () => RELEASE_NOTES_EXTENSION,
   ROUTABLE_PAGES_DIRECTORY_NAME: () => ROUTABLE_PAGES_DIRECTORY_NAME,
   SCRIPT_EXTENSION: () => SCRIPT_EXTENSION,
@@ -59,6 +64,7 @@ __export(index_exports, {
   decrypt: () => decrypt,
   deserializeEnvelope: () => deserializeEnvelope,
   encrypt: () => encrypt,
+  errorIssue: () => errorIssue,
   generateKeypair: () => generateKeypair,
   getAdornmentIcon: () => getAdornmentIcon,
   getMinimizedConfig: () => getMinimizedConfig,
@@ -74,6 +80,7 @@ __export(index_exports, {
   thumbnailImageExtensions: () => thumbnailImageExtensions,
   transformDeployablePlugin: () => transformDeployablePlugin,
   triggerImageExtensions: () => triggerImageExtensions,
+  validatePluginApp: () => validatePluginApp,
   zipToUint8Array: () => zipToUint8Array
 });
 module.exports = __toCommonJS(index_exports);
@@ -111,26 +118,54 @@ var minifyFiles = async (files) => {
 
 // src/lib/apiNames.ts
 var sanitizeToAPIName = (name) => {
-  return name.toLowerCase().replace(/[^a-z0-9\-\s]/g, "").replace(/\s+/g, "_");
+  return name.toLowerCase().replace(/[-\s]+/g, "_").replace(/[^a-z0-9_]/g, "");
 };
+var resolveApiName = (explicit, directoryName) => typeof explicit === "string" && explicit !== "" ? explicit : sanitizeToAPIName(directoryName);
 var scriptRuntimeToApiName = (runtime) => {
   const result = runtime.replace(/\s+/g, "-").replace(/\./g, "-");
   return result;
 };
 
-// src/lib/image.ts
-var imagetoUint8Array = (base64Image) => {
-  const byteCharacters = atob(base64Image);
-  const byteNumbers = new Array(byteCharacters.length);
-  for (let i = 0; i < byteCharacters.length; i++) {
-    byteNumbers[i] = byteCharacters.charCodeAt(i);
+// src/lib/issues.ts
+var errorIssue = (rule, message, path, pluginApiName) => ({
+  rule,
+  severity: "error",
+  message,
+  ...path !== void 0 && { path },
+  ...pluginApiName !== void 0 && { pluginApiName }
+});
+var warningIssue = (rule, message, path, pluginApiName) => ({
+  rule,
+  severity: "warning",
+  message,
+  ...path !== void 0 && { path },
+  ...pluginApiName !== void 0 && { pluginApiName }
+});
+var PluginValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    const errors = issues.filter((i) => i.severity === "error");
+    const details = errors.map((i) => `${i.path ? `${i.path}: ` : ""}${i.message}`).join("\n");
+    super(`Plugin app validation failed with ${String(errors.length)} error(s):
+${details}`);
+    this.name = "PluginValidationError";
+    this.issues = issues;
   }
-  return new Uint8Array(byteNumbers);
-};
-var zipToUint8Array = (zip) => {
-  return Uint8Array.from(zip);
 };
 
+// src/types/manifest.ts
+var PUBLISHABLE_ENVIRONMENTS = [
+  "go",
+  "fmo",
+  "staging",
+  "integration",
+  "e2e-integration",
+  "e2e-staging",
+  "test1"
+];
+var ENVIRONMENT_ALIASES = ["prod", "dev", "testing"];
+var ENVIRONMENTS = [...PUBLISHABLE_ENVIRONMENTS, ...ENVIRONMENT_ALIASES];
+
 // src/lib/structure.ts
 var thumbnailImageExtensions = ["png"];
 var triggerImageExtensions = [...thumbnailImageExtensions, "svg"];
@@ -148,9 +183,7 @@ var USER_SETUP_ASSISTANT_DIRECTORY_NAME = "userSetupAssistant";
 var CALENDAR_SOURCES_DIRECTORY_NAME = "calendarSources";
 var VIEWS_DIRECTORY_NAME = "views";
 var BLOCKS_DIRECTORY_NAME = "blocks";
-var THUMBNAIL_FILE_NAMES = thumbnailImageExtensions.map(
-  (ext) => `thumbnail.${ext}`
-);
+var THUMBNAIL_FILE_NAMES = thumbnailImageExtensions.map((ext) => `thumbnail.${ext}`);
 var RELEASE_NOTES_EXTENSION = "md";
 var SCRIPT_EXTENSION = "js";
 var MAIN_SCRIPT_FILE = `script.${SCRIPT_EXTENSION}`;
@@ -162,49 +195,70 @@ var CONFIG_FILE_NAME = "config.json";
 var STYLES_FILE_NAME = "styles.css";
 var MANIFEST_FILE_NAME = "kizen.json";
 var KZN_FILE_NAME = "import.kzn";
-var maybeParseConfig = (content, path) => {
+var tryParseConfig = (content, path, pluginApiName) => {
   if (!content) {
-    throw new Error(`No content provided for config file: ${path}`);
+    return {
+      issue: errorIssue(
+        "structure/config-content",
+        `No content provided for config file: ${path}`,
+        path,
+        pluginApiName
+      )
+    };
   }
   try {
-    return JSON.parse(content);
+    return { config: JSON.parse(content) };
   } catch {
-    throw new Error(`Failed to parse config content: ${path}`);
+    return {
+      issue: errorIssue(
+        "structure/config-parse",
+        `Failed to parse ${CONFIG_FILE_NAME} as JSON.`,
+        path,
+        pluginApiName
+      )
+    };
   }
 };
+var maybeParseConfig = (content, path, pluginApiName) => {
+  const result = tryParseConfig(content, path, pluginApiName);
+  if ("issue" in result) throw new PluginValidationError([result.issue]);
+  return result.config;
+};
 var getMinimizedConfig = (config, entry, splitPath, consideredFiles) => {
-  const result = config["minimized_config"] ?? {};
-  if (result["customIconFile"]) {
+  const result = config.minimized_config ?? {};
+  const customIconFile = result.customIconFile;
+  if (typeof customIconFile === "string" && customIconFile) {
     let basePath = splitPath.slice(0, -1).join("/");
     if (entry.endsWith("/")) {
       basePath = `${entry}${basePath}`;
     } else {
       basePath = `${entry}/${basePath}`;
     }
-    const filePath = `${basePath}/${result["customIconFile"]}`;
+    const filePath = `${basePath}/${customIconFile}`;
     const file = consideredFiles.find((f) => f.path === filePath);
     if (file?.base64Image) {
-      let extension = filePath.split(".").pop()?.toLowerCase();
+      let extension = filePath.split(".").pop()?.toLowerCase() ?? "";
       if (extension === "svg") {
         extension = "svg+xml";
       }
-      result["customIcon"] = `data:image/${extension};base64,${file.base64Image}`;
+      result.customIcon = `data:image/${extension};base64,${file.base64Image}`;
     }
   }
   return result;
 };
 var getAdornmentIcon = (config, entry, splitPath, consideredFiles) => {
-  if (config["customIconFile"]) {
+  const customIconFile = config.customIconFile;
+  if (typeof customIconFile === "string" && customIconFile) {
     let basePath = splitPath.slice(0, -1).join("/");
     if (entry.endsWith("/")) {
       basePath = `${entry}${basePath}`;
     } else {
       basePath = `${entry}/${basePath}`;
     }
-    const filePath = `${basePath}/${config["customIconFile"]}`;
+    const filePath = `${basePath}/${customIconFile}`;
     const file = consideredFiles.find((f) => f.path === filePath);
     if (file?.base64Image) {
-      let extension = filePath.split(".").pop()?.toLowerCase();
+      let extension = filePath.split(".").pop()?.toLowerCase() ?? "";
       if (extension === "svg") {
         extension = "svg+xml";
       }
@@ -214,6 +268,411 @@ var getAdornmentIcon = (config, entry, splitPath, consideredFiles) => {
   return "";
 };
 
+// src/lib/validate.ts
+var API_NAME_PATTERN = /^[a-z_][a-z0-9_]+$/;
+var API_NAME_HINT = "must start with a letter or underscore and contain only lowercase letters, numbers, or underscores (minimum 2 characters)";
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+var PATH_PATTERN = /^[a-zA-Z][a-zA-Z0-9_\-/]*$/;
+var SUPPORTED_ENGINES = ["1.0.0"];
+var CONFIG_REQUIRED_DIRECTORIES = [
+  FLOATING_FRAMES_DIRECTORY_NAME,
+  BLOCKS_DIRECTORY_NAME,
+  DATA_ADORNMENTS_DIRECTORY_NAME,
+  TOOLBAR_ITEMS_DIRECTORY_NAME,
+  ROUTABLE_PAGES_DIRECTORY_NAME,
+  BROWSER_ROUTE_SCRIPTS_DIRECTORY_NAME,
+  JS_ACTIONS_DIRECTORY_NAME,
+  OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME,
+  AUTOMATION_STEPS_DIRECTORY_NAME,
+  CALENDAR_SOURCES_DIRECTORY_NAME
+];
+var API_NAMED_DIRECTORIES = /* @__PURE__ */ new Set([
+  FLOATING_FRAMES_DIRECTORY_NAME,
+  BLOCKS_DIRECTORY_NAME,
+  TOOLBAR_ITEMS_DIRECTORY_NAME,
+  ROUTABLE_PAGES_DIRECTORY_NAME,
+  BROWSER_ROUTE_SCRIPTS_DIRECTORY_NAME,
+  JS_ACTIONS_DIRECTORY_NAME,
+  OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME,
+  AUTOMATION_STEPS_DIRECTORY_NAME,
+  CALENDAR_SOURCES_DIRECTORY_NAME,
+  VIEWS_DIRECTORY_NAME
+]);
+var COMPONENT_DIRECTORIES = [...CONFIG_REQUIRED_DIRECTORIES, VIEWS_DIRECTORY_NAME];
+var isNonEmptyString = (value) => typeof value === "string" && value !== "";
+var validateManifestFields = (manifest, label, pluginApiName) => {
+  const issues = [];
+  const problem = (rule, message) => {
+    issues.push(errorIssue(rule, `${label}: ${message}`, MANIFEST_FILE_NAME, pluginApiName));
+  };
+  const warn = (rule, message) => {
+    issues.push(warningIssue(rule, `${label}: ${message}`, MANIFEST_FILE_NAME, pluginApiName));
+  };
+  const requireString = (field) => {
+    const value = manifest[field];
+    if (!isNonEmptyString(value)) {
+      problem("manifest/required-field", `${field} is required and must be a non-empty string.`);
+      return null;
+    }
+    return value;
+  };
+  const optionalString = (field) => {
+    const value = manifest[field];
+    if (value === void 0) {
+      return null;
+    }
+    if (!isNonEmptyString(value)) {
+      problem("manifest/required-field", `${field} must be a non-empty string when present.`);
+      return null;
+    }
+    return value;
+  };
+  const optionalStringArray = (field, rule) => {
+    const value = manifest[field];
+    if (value === void 0) {
+      return null;
+    }
+    if (!Array.isArray(value) || !value.every(isNonEmptyString)) {
+      problem(rule, `${field} must be an array of non-empty strings when present.`);
+      return null;
+    }
+    return value;
+  };
+  const version = requireString("version");
+  if (version !== null && !SEMVER_PATTERN.test(version)) {
+    problem(
+      "manifest/version-format",
+      `version must be a semantic version (e.g. 1.0.0), got "${version}".`
+    );
+  }
+  const apiName = requireString("api_name");
+  if (apiName !== null && !API_NAME_PATTERN.test(apiName)) {
+    problem("manifest/api-name-format", `api_name "${apiName}" is invalid: ${API_NAME_HINT}.`);
+  }
+  requireString("name");
+  requireString("description");
+  const engine = requireString("engine");
+  if (engine !== null && !SUPPORTED_ENGINES.includes(engine)) {
+    problem(
+      "manifest/engine-version",
+      `engine must be one of ${SUPPORTED_ENGINES.join(", ")}, got "${engine}".`
+    );
+  }
+  const entry = requireString("entry");
+  if (entry !== null && !PATH_PATTERN.test(entry)) {
+    problem(
+      "manifest/entry-path",
+      `entry must be a directory path matching ${String(PATH_PATTERN)}, got "${entry}".`
+    );
+  }
+  const releaseNotesDirectory = optionalString("release_notes_directory");
+  if (releaseNotesDirectory !== null && !PATH_PATTERN.test(releaseNotesDirectory)) {
+    problem(
+      "manifest/release-notes-directory-path",
+      `release_notes_directory must be a directory path matching ${String(PATH_PATTERN)}, got "${releaseNotesDirectory}".`
+    );
+  }
+  optionalStringArray("release_branches", "manifest/release-branches");
+  const releaseEnvironments = optionalStringArray(
+    "release_environments",
+    "manifest/release-environments"
+  );
+  if (releaseEnvironments !== null) {
+    for (const env of releaseEnvironments) {
+      if (!ENVIRONMENTS.includes(env)) {
+        problem(
+          "manifest/release-environments",
+          `release_environments must only contain ${ENVIRONMENTS.join(", ")}. Instead, got "${env}".`
+        );
+      }
+    }
+  }
+  const developerBusinessId = manifest.developer_business_id;
+  if (developerBusinessId !== void 0) {
+    if (isNonEmptyString(developerBusinessId)) {
+      const distinctValidEnvs = new Set(
+        (releaseEnvironments ?? []).filter(
+          (env) => ENVIRONMENTS.includes(env)
+        )
+      );
+      if (distinctValidEnvs.size >= 2) {
+        warn(
+          "manifest/developer-business-id-environments",
+          "developer_business_id is a single id but release_environments targets multiple environments; a business id generally exists in only one environment, so publishing to the others will fail - use the per-environment object form instead."
+        );
+      }
+    } else if (typeof developerBusinessId === "object" && developerBusinessId !== null && !Array.isArray(developerBusinessId)) {
+      for (const [env, id] of Object.entries(developerBusinessId)) {
+        if (!PUBLISHABLE_ENVIRONMENTS.includes(env)) {
+          problem(
+            "manifest/developer-business-id",
+            `developer_business_id has an invalid environment key "${env}": keys must be one of ${PUBLISHABLE_ENVIRONMENTS.join(", ")}. Aliases like ${ENVIRONMENT_ALIASES.join(", ")} are not valid keys here - the publisher indexes by concrete environment, so alias keys silently resolve to nothing.`
+          );
+        }
+        if (!isNonEmptyString(id)) {
+          problem(
+            "manifest/developer-business-id",
+            `developer_business_id["${env}"] must be a non-empty string.`
+          );
+        }
+      }
+    } else {
+      problem(
+        "manifest/developer-business-id",
+        "developer_business_id must be a non-empty string or an object mapping publishable environments to ids."
+      );
+    }
+  }
+  return issues;
+};
+var collectComponents = (files, entry) => {
+  const entryPrefix = entry.endsWith("/") ? entry : `${entry}/`;
+  const components = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.path.startsWith(entryPrefix) || file.path.endsWith(".DS_Store")) {
+      continue;
+    }
+    const [directory, name, child] = file.path.slice(entryPrefix.length).split("/");
+    if (!directory || !name || !COMPONENT_DIRECTORIES.includes(directory)) {
+      continue;
+    }
+    const key = `${directory}/${name}`;
+    const existing = components.get(key) ?? {
+      directory,
+      name,
+      configFile: void 0
+    };
+    if (child === CONFIG_FILE_NAME) {
+      existing.configFile = file;
+    }
+    components.set(key, existing);
+  }
+  return [...components.values()];
+};
+var PAGE_LIKE_DIRECTORIES = /* @__PURE__ */ new Set([ROUTABLE_PAGES_DIRECTORY_NAME, VIEWS_DIRECTORY_NAME]);
+var validateComponent = (component, entry, pluginApiName) => {
+  const { directory, name, configFile } = component;
+  const entryBase = entry.endsWith("/") ? entry.slice(0, -1) : entry;
+  const componentPath = `${entryBase}/${directory}/${name}`;
+  const issues = [];
+  const apiNameIssue = (value, derived2, path) => {
+    const derivedNote = derived2 ? ` (derived from directory name "${name}")` : "";
+    const derivedFix = derived2 ? ` Set an explicit api_name in ${CONFIG_FILE_NAME}.` : "";
+    issues.push(
+      errorIssue(
+        "structure/api-name-format",
+        `api_name "${value}"${derivedNote} is invalid: ${API_NAME_HINT}.${derivedFix}`,
+        path,
+        pluginApiName
+      )
+    );
+  };
+  if (!configFile) {
+    if (CONFIG_REQUIRED_DIRECTORIES.includes(directory)) {
+      issues.push(
+        errorIssue(
+          "structure/missing-config",
+          `Missing required ${CONFIG_FILE_NAME} for ${directory}/${name}.`,
+          componentPath,
+          pluginApiName
+        )
+      );
+    }
+    if (API_NAMED_DIRECTORIES.has(directory)) {
+      const derived2 = sanitizeToAPIName(name);
+      if (!API_NAME_PATTERN.test(derived2)) {
+        apiNameIssue(derived2, true, componentPath);
+      } else {
+        return {
+          issues,
+          path: componentPath,
+          resolved: { apiName: derived2, path: componentPath }
+        };
+      }
+    }
+    return { issues, path: componentPath };
+  }
+  const result = tryParseConfig(configFile.content, configFile.path, pluginApiName);
+  if ("issue" in result) {
+    return { issues: [result.issue], path: componentPath };
+  }
+  const config = result.config;
+  if (directory === FLOATING_FRAMES_DIRECTORY_NAME) {
+    const defaultPosition = config.default_position;
+    const minimizedStyle = config.minimized_style;
+    if ((defaultPosition === "bottom-left-fixed" || defaultPosition === "bottom-right-fixed") && minimizedStyle !== void 0 && minimizedStyle !== "circle") {
+      issues.push(
+        errorIssue(
+          "structure/fixed-frame-minimized-style",
+          `Floating frame "${name}" sets default_position "${defaultPosition}" with minimized_style ${JSON.stringify(minimizedStyle)}. Fixed-position frames require minimized_style "circle" (or omit it).`,
+          configFile.path,
+          pluginApiName
+        )
+      );
+    }
+  }
+  if (!API_NAMED_DIRECTORIES.has(directory)) {
+    return { issues, path: componentPath };
+  }
+  const explicit = config.api_name;
+  if (isNonEmptyString(explicit)) {
+    if (!API_NAME_PATTERN.test(explicit)) {
+      apiNameIssue(explicit, false, configFile.path);
+      return { issues, path: componentPath };
+    }
+    return {
+      issues,
+      path: componentPath,
+      resolved: { apiName: explicit, path: configFile.path }
+    };
+  }
+  if (explicit) {
+    issues.push(
+      errorIssue(
+        "structure/api-name-format",
+        "api_name must be a non-empty string.",
+        configFile.path,
+        pluginApiName
+      )
+    );
+    return { issues, path: componentPath };
+  }
+  const derived = sanitizeToAPIName(name);
+  if (!API_NAME_PATTERN.test(derived)) {
+    apiNameIssue(derived, true, configFile.path);
+    return { issues, path: componentPath };
+  }
+  return {
+    issues,
+    path: componentPath,
+    resolved: { apiName: derived, path: configFile.path }
+  };
+};
+var validateManifestList = (manifests, isMultiManifest, files) => {
+  const issues = [];
+  const seenApiNames = /* @__PURE__ */ new Map();
+  manifests.forEach((manifest, index) => {
+    const label = isMultiManifest ? `${MANIFEST_FILE_NAME} entry #${String(index + 1)}` : MANIFEST_FILE_NAME;
+    if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) {
+      issues.push(errorIssue("manifest/shape", `${label}: must be a JSON object.`, MANIFEST_FILE_NAME));
+      return;
+    }
+    const record = manifest;
+    const rawApiName = record.api_name;
+    const pluginApiName = isNonEmptyString(rawApiName) ? rawApiName : void 0;
+    issues.push(...validateManifestFields(record, label, pluginApiName));
+    if (pluginApiName !== void 0) {
+      const firstIndex = seenApiNames.get(pluginApiName);
+      if (firstIndex !== void 0) {
+        issues.push(
+          errorIssue(
+            "manifest/duplicate-api-name",
+            `${label}: duplicate api_name "${pluginApiName}" already used by entry #${String(firstIndex + 1)}. Plugins in a multi-plugin manifest must have unique api_names.`,
+            MANIFEST_FILE_NAME,
+            pluginApiName
+          )
+        );
+      } else {
+        seenApiNames.set(pluginApiName, index);
+      }
+    }
+    const entry = record.entry;
+    if (isNonEmptyString(entry) && PATH_PATTERN.test(entry)) {
+      const seenResolved = /* @__PURE__ */ new Map();
+      const seenPageNames = /* @__PURE__ */ new Map();
+      for (const component of collectComponents(files, entry)) {
+        const {
+          issues: componentIssues,
+          path: componentPath,
+          resolved
+        } = validateComponent(component, entry, pluginApiName);
+        issues.push(...componentIssues);
+        if (PAGE_LIKE_DIRECTORIES.has(component.directory)) {
+          const firstPage = seenPageNames.get(component.name);
+          if (firstPage !== void 0) {
+            issues.push(
+              errorIssue(
+                "structure/duplicate-component-name",
+                `duplicate component name "${component.name}": ${component.directory}/${component.name} (${componentPath}) collides with ${firstPage.directory}/${component.name} (${firstPage.path}). pages and views share one routable-pages collection, so names must be unique across both directories.`,
+                componentPath,
+                pluginApiName
+              )
+            );
+          } else {
+            seenPageNames.set(component.name, {
+              path: componentPath,
+              directory: component.directory
+            });
+          }
+        }
+        if (resolved) {
+          const key = `${component.directory}
+${resolved.apiName}`;
+          const firstPath = seenResolved.get(key);
+          if (firstPath !== void 0) {
+            issues.push(
+              errorIssue(
+                "structure/duplicate-api-name",
+                `duplicate api_name "${resolved.apiName}" in ${component.directory}: ${resolved.path} collides with ${firstPath}. Sibling ${component.directory} components must resolve to unique api_names.`,
+                resolved.path,
+                pluginApiName
+              )
+            );
+          } else {
+            seenResolved.set(key, resolved.path);
+          }
+        }
+      }
+    }
+  });
+  return issues;
+};
+var validatePluginApp = (files) => {
+  const manifestFile = files.find((f) => f.path === MANIFEST_FILE_NAME);
+  if (!manifestFile) {
+    return [
+      errorIssue(
+        "manifest/missing",
+        `Missing ${MANIFEST_FILE_NAME} at the root of the plugin directory.`,
+        MANIFEST_FILE_NAME
+      )
+    ];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(manifestFile.content);
+  } catch {
+    return [
+      errorIssue(
+        "manifest/parse",
+        `${MANIFEST_FILE_NAME} could not be parsed. Is it properly formatted JSON?`,
+        MANIFEST_FILE_NAME
+      )
+    ];
+  }
+  const isMultiManifest = Array.isArray(parsed);
+  const manifests = isMultiManifest ? parsed : [parsed];
+  return validateManifestList(manifests, isMultiManifest, files);
+};
+var validatePackagedManifests = (manifests, files) => {
+  const isMultiManifest = Array.isArray(manifests);
+  const list = isMultiManifest ? manifests : [manifests];
+  return validateManifestList(list, isMultiManifest, files);
+};
+
+// src/lib/image.ts
+var imagetoUint8Array = (base64Image) => {
+  const byteCharacters = atob(base64Image);
+  const byteNumbers = new Array(byteCharacters.length);
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  return new Uint8Array(byteNumbers);
+};
+var zipToUint8Array = (zip) => {
+  return Uint8Array.from(zip);
+};
+
 // src/lib/package.ts
 var replacementVar = "__kizen_state";
 var prepend = "const __kizen_utils = {};\n";
@@ -226,16 +685,13 @@ return ${inner}; })()`;
 };
 var mapFields = (fields, scriptsByKey) => {
   return fields.map((field) => {
-    if (field["type"] === "container" && field["fields"] && Array.isArray(field["fields"])) {
+    if (field.type === "container" && field.fields && Array.isArray(field.fields)) {
       return {
         ...field,
-        fields: mapFields(
-          field["fields"],
-          scriptsByKey
-        )
+        fields: mapFields(field.fields, scriptsByKey)
       };
     }
-    const fieldKey = field["key"];
+    const fieldKey = field.key;
     const scripts = scriptsByKey[fieldKey];
     if (scripts) {
       const result = { ...field };
@@ -248,12 +704,7 @@ var mapFields = (fields, scriptsByKey) => {
       ]) {
         const fn = scripts[fnName];
         if (fn) {
-          result[fnName] = convertToSelfInvokingFunction(
-            fn,
-            replacementVar,
-            {},
-            prepend
-          );
+          result[fnName] = convertToSelfInvokingFunction(fn, replacementVar, {}, prepend);
         }
       }
       return result;
@@ -265,19 +716,13 @@ var processSetupAssistantFromFiles = (assistantConfig, scripts) => {
   if (!assistantConfig) {
     return void 0;
   }
-  const scriptsByKey = scripts.reduce(
-    (acc, script) => {
-      (acc[script.key] ??= {})[script.type] = script.content;
-      return acc;
-    },
-    {}
-  );
+  const scriptsByKey = scripts.reduce((acc, script) => {
+    (acc[script.key] ??= {})[script.type] = script.content;
+    return acc;
+  }, {});
   const newConfig = { ...assistantConfig };
-  if (newConfig["fields"] && Array.isArray(newConfig["fields"])) {
-    newConfig["fields"] = mapFields(
-      newConfig["fields"],
-      scriptsByKey
-    );
+  if (newConfig.fields && Array.isArray(newConfig.fields)) {
+    newConfig.fields = mapFields(newConfig.fields, scriptsByKey);
   }
   return newConfig;
 };
@@ -285,10 +730,12 @@ var processOnePluginFromManifest = (manifest, files) => {
   const entry = manifest.entry;
   const releaseNotesDirectory = manifest.release_notes_directory;
   const apiName = manifest.api_name;
+  const entryPrefix = entry.endsWith("/") ? entry : `${entry}/`;
   const consideredFiles = files.filter(
-    (f) => f.path !== MANIFEST_FILE_NAME && f.path.startsWith(entry) && !f.path.endsWith(".DS_Store")
+    (f) => f.path !== MANIFEST_FILE_NAME && f.path.startsWith(entryPrefix) && !f.path.endsWith(".DS_Store")
   );
-  const releaseNotesFiles = releaseNotesDirectory ? files.filter((f) => f.path.startsWith(releaseNotesDirectory)) : [];
+  const releaseNotesPrefix = releaseNotesDirectory?.endsWith("/") ? releaseNotesDirectory : `${releaseNotesDirectory ?? ""}/`;
+  const releaseNotesFiles = releaseNotesDirectory ? files.filter((f) => f.path.startsWith(releaseNotesPrefix)) : [];
   const { version } = manifest;
   const releaseNotes = releaseNotesFiles.find(
     (file) => file.path.endsWith(`${version}.${RELEASE_NOTES_EXTENSION}`)
@@ -306,18 +753,16 @@ var processOnePluginFromManifest = (manifest, files) => {
   let thumbnail = null;
   let kznFile = null;
   let hasBlockingCondition = false;
-  const requiredConfigFiles = {};
   let setupAssistantJSON = null;
   const setupAssistantFunctions = [];
   let userSetupAssistantJSON = null;
   const userSetupAssistantFunctions = [];
   for (const file of consideredFiles) {
-    let strippedPath = file.path.replace(entry, "");
-    strippedPath = strippedPath.startsWith("/") ? strippedPath.substring(1) : strippedPath;
+    const strippedPath = file.path.slice(entryPrefix.length);
     const splitPath = strippedPath.split("/");
     if (splitPath[0] === SETUP_ASSISTANT_DIRECTORY_NAME) {
       if (splitPath[1] === "assistant.json") {
-        setupAssistantJSON = maybeParseConfig(file.content, file.path);
+        setupAssistantJSON = maybeParseConfig(file.content, file.path, apiName);
       } else {
         const assistantKey = splitPath[1];
         if (assistantKey && splitPath[2]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
@@ -330,7 +775,7 @@ var processOnePluginFromManifest = (manifest, files) => {
       }
     } else if (splitPath[0] === USER_SETUP_ASSISTANT_DIRECTORY_NAME) {
       if (splitPath[1] === "assistant.json") {
-        userSetupAssistantJSON = maybeParseConfig(file.content, file.path);
+        userSetupAssistantJSON = maybeParseConfig(file.content, file.path, apiName);
       } else {
         const assistantKey = splitPath[1];
         if (assistantKey && splitPath[2]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
@@ -346,30 +791,27 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!floatingFrameName) {
         continue;
       }
-      if (!floatingFrames[floatingFrameName]) {
-        requiredConfigFiles[`frame:${floatingFrameName}`] = true;
-        floatingFrames[floatingFrameName] = {
-          name: "",
-          api_name: "",
-          title: "",
-          type: "script",
-          css: "",
-          event_scripts: {},
-          default_position: "bottom-right",
-          header_color: "",
-          header_text_color: "",
-          height: 0,
-          width: 0,
-          ignore: [],
-          match: [],
-          message_handler: "",
-          minimized_style: "circle",
-          minimized_config: {},
-          script: "",
-          html: "",
-          when: ""
-        };
-      }
+      floatingFrames[floatingFrameName] ??= {
+        name: "",
+        api_name: "",
+        title: "",
+        type: "script",
+        css: "",
+        event_scripts: {},
+        default_position: "bottom-right",
+        header_color: "",
+        header_text_color: "",
+        height: 0,
+        width: 0,
+        ignore: [],
+        match: [],
+        message_handler: "",
+        minimized_style: "circle",
+        minimized_config: {},
+        script: "",
+        html: "",
+        when: ""
+      };
       const frame = floatingFrames[floatingFrameName];
       if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
         if (splitPath[3]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
@@ -377,27 +819,22 @@ var processOnePluginFromManifest = (manifest, files) => {
           frame.event_scripts[functionName] = file.minified;
         }
       } else if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`frame:${floatingFrameName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        frame.name = config["name"] || "";
-        frame.api_name = config["api_name"] || sanitizeToAPIName(floatingFrameName);
-        frame.title = config["title"] || "";
-        frame.default_position = config["default_position"] || "bottom-right";
-        frame.header_color = config["header_color"] || "";
-        frame.header_text_color = config["header_text_color"] || "";
-        frame.height = config["height"] || 0;
-        frame.width = config["width"] || 0;
-        frame.ignore = config["ignore"] || [];
-        frame.match = config["match"] || [];
-        frame.html = config["html"] || "";
-        frame.minimized_style = config["minimized_style"] || "circle";
-        frame.minimized_config = getMinimizedConfig(
-          config,
-          entry,
-          splitPath,
-          consideredFiles
-        );
-        frame.when = config["when"] || "";
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        frame.name = config.name || "";
+        frame.api_name = resolveApiName(config.api_name, floatingFrameName);
+        frame.title = config.title || "";
+        frame.default_position = config.default_position || "bottom-right";
+        frame.header_color = config.header_color || "";
+        frame.header_text_color = config.header_text_color || "";
+        frame.height = config.height || 0;
+        frame.width = config.width || 0;
+        frame.ignore = Array.isArray(config.ignore) ? config.ignore : [];
+        frame.match = Array.isArray(config.match) ? config.match : [];
+        frame.html = config.html || "";
+        const minimizedStyle = config.minimized_style;
+        frame.minimized_style = minimizedStyle === "bar" || minimizedStyle === "circle" || minimizedStyle === "none" ? minimizedStyle : "circle";
+        frame.minimized_config = getMinimizedConfig(config, entry, splitPath, consideredFiles);
+        frame.when = config.when || "";
       } else if (splitPath[2] === MESSAGE_SCRIPT_FILE) {
         frame.message_handler = file.minified;
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
@@ -410,21 +847,18 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!blockName) {
         continue;
       }
-      if (!blocks[blockName]) {
-        requiredConfigFiles[`block:${blockName}`] = true;
-        blocks[blockName] = {
-          name: "",
-          api_name: "",
-          min_w: 1,
-          max_w: 12,
-          min_h: 1,
-          max_h: 12,
-          event_scripts: {},
-          script: "",
-          styles: "",
-          when: ""
-        };
-      }
+      blocks[blockName] ??= {
+        name: "",
+        api_name: "",
+        min_w: 1,
+        max_w: 12,
+        min_h: 1,
+        max_h: 12,
+        event_scripts: {},
+        script: "",
+        styles: "",
+        when: ""
+      };
       const block = blocks[blockName];
       if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
         if (splitPath[3]?.endsWith(`.${SCRIPT_EXTENSION}`)) {
@@ -432,22 +866,21 @@ var processOnePluginFromManifest = (manifest, files) => {
           block.event_scripts[functionName] = file.minified;
         }
       } else if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`block:${blockName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        block.name = config["name"] || "";
-        block.api_name = config["api_name"] || sanitizeToAPIName(blockName);
-        block.min_w = config["min_w"] || 1;
-        block.max_w = config["max_w"] || 12;
-        block.min_h = config["min_h"] || 1;
-        block.max_h = config["max_h"] || 12;
-        if (config["recommended_height"] != null) {
-          block.recommended_height = config["recommended_height"];
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        block.name = config.name || "";
+        block.api_name = resolveApiName(config.api_name, blockName);
+        block.min_w = config.min_w || 1;
+        block.max_w = config.max_w || 12;
+        block.min_h = config.min_h || 1;
+        block.max_h = config.max_h || 12;
+        if (config.recommended_height != null) {
+          block.recommended_height = config.recommended_height;
         }
-        if (config["types"]) {
-          block.types = config["types"];
+        if (config.types) {
+          block.types = config.types;
         }
-        block.when = config["when"] || "";
-        if (config["when"]) {
+        block.when = config.when || "";
+        if (config.when) {
           hasBlockingCondition = true;
         }
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
@@ -460,31 +893,23 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!dataAdornmentName) {
         continue;
       }
-      if (!dataAdornments[dataAdornmentName]) {
-        requiredConfigFiles[`dataAdornment:${dataAdornmentName}`] = true;
-        dataAdornments[dataAdornmentName] = {
-          config: { icon: "", color: "", tooltip: "" },
-          field_type: "phonenumber",
-          script: "",
-          when: ""
-        };
-      }
+      dataAdornments[dataAdornmentName] ??= {
+        config: { icon: "", color: "", tooltip: "" },
+        field_type: "phonenumber",
+        script: "",
+        when: ""
+      };
       const adornment = dataAdornments[dataAdornmentName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`dataAdornment:${dataAdornmentName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        adornment.config.icon = config["icon"] || "";
-        adornment.config.color = config["color"] || "";
-        adornment.config.tooltip = config["tooltip"] || "";
-        adornment.config.customIcon = getAdornmentIcon(
-          config,
-          entry,
-          splitPath,
-          consideredFiles
-        );
-        adornment.field_type = config["field_type"] || "phonenumber";
-        adornment.when = config["when"] || "";
-        if (config["when"]) hasBlockingCondition = true;
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        adornment.config.icon = config.icon || "";
+        adornment.config.color = config.color || "";
+        adornment.config.tooltip = config.tooltip || "";
+        adornment.config.customIcon = getAdornmentIcon(config, entry, splitPath, consideredFiles);
+        const fieldType = config.field_type;
+        adornment.field_type = fieldType === "phonenumber" || fieldType === "date" || fieldType === "datetime" ? fieldType : "phonenumber";
+        adornment.when = config.when || "";
+        if (config.when) hasBlockingCondition = true;
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         adornment.script = file.minified;
       }
@@ -493,27 +918,23 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!toolbarItemName) {
         continue;
       }
-      if (!toolbarItems[toolbarItemName]) {
-        requiredConfigFiles[`toolbarItem:${toolbarItemName}`] = true;
-        toolbarItems[toolbarItemName] = {
-          api_name: "",
-          label: "",
-          icon: "",
-          color: "",
-          script: "",
-          when: ""
-        };
-      }
+      toolbarItems[toolbarItemName] ??= {
+        api_name: "",
+        label: "",
+        icon: "",
+        color: "",
+        script: "",
+        when: ""
+      };
       const item = toolbarItems[toolbarItemName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`toolbarItem:${toolbarItemName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        item.api_name = config["api_name"] || sanitizeToAPIName(toolbarItemName);
-        item.label = config["label"] || "";
-        item.icon = config["icon"] || "";
-        item.color = config["color"] || "";
-        item.when = config["when"] || "";
-        if (config["when"]) hasBlockingCondition = true;
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        item.api_name = resolveApiName(config.api_name, toolbarItemName);
+        item.label = config.label || "";
+        item.icon = config.icon || "";
+        item.color = config.color || "";
+        item.when = config.when || "";
+        if (config.when) hasBlockingCondition = true;
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         item.script = file.minified;
       }
@@ -522,23 +943,20 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!pageName) {
         continue;
       }
-      if (!routablePages[pageName]) {
-        requiredConfigFiles[`page:${pageName}`] = true;
-        routablePages[pageName] = {
-          name: pageName,
-          api_name: "",
-          event_scripts: {},
-          script: "",
-          callback: "",
-          css: "",
-          is_toolbar_item: false,
-          toolbar_color: "",
-          toolbar_icon: "",
-          type: "script",
-          html: "",
-          iframe_url: ""
-        };
-      }
+      routablePages[pageName] ??= {
+        name: pageName,
+        api_name: "",
+        event_scripts: {},
+        script: "",
+        callback: "",
+        css: "",
+        is_toolbar_item: false,
+        toolbar_color: "",
+        toolbar_icon: "",
+        type: "script",
+        html: "",
+        iframe_url: ""
+      };
       const page = routablePages[pageName];
       if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
         if (splitPath[3]?.endsWith(SCRIPT_EXTENSION)) {
@@ -546,13 +964,12 @@ var processOnePluginFromManifest = (manifest, files) => {
           page.event_scripts[functionName] = file.minified;
         }
       } else if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`page:${pageName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        page.api_name = config["api_name"] || sanitizeToAPIName(pageName);
-        page.name = config["name"] || pageName;
-        page.is_toolbar_item = config["is_toolbar_item"] || false;
-        page.toolbar_color = config["toolbar_color"] || "";
-        page.toolbar_icon = config["toolbar_icon"] || "";
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        page.api_name = resolveApiName(config.api_name, pageName);
+        page.name = config.name || pageName;
+        page.is_toolbar_item = config.is_toolbar_item || false;
+        page.toolbar_color = config.toolbar_color || "";
+        page.toolbar_icon = config.toolbar_icon || "";
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         page.script = file.minified;
       } else if (splitPath[2] === CALLBACK_SCRIPT_FILE) {
@@ -565,39 +982,35 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!stepName) {
         continue;
       }
-      if (!automationSteps[stepName]) {
-        requiredConfigFiles[`automationStep:${stepName}`] = true;
-        automationSteps[stepName] = {
-          name: "",
-          action_step_api_name: "",
-          overall_description: "",
-          action_description: "",
-          action_type: "",
-          script_runtime: scriptRuntimeToApiName("python 3.12"),
-          secrets: [],
-          inputs: [],
-          outputs: [],
-          script: "",
-          when: ""
-        };
-      }
+      automationSteps[stepName] ??= {
+        name: "",
+        action_step_api_name: "",
+        overall_description: "",
+        action_description: "",
+        action_type: "",
+        script_runtime: scriptRuntimeToApiName("python 3.12"),
+        secrets: [],
+        inputs: [],
+        outputs: [],
+        script: "",
+        when: ""
+      };
       const step = automationSteps[stepName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`automationStep:${stepName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        step.name = config["name"] || stepName;
-        step.action_step_api_name = config["api_name"] || sanitizeToAPIName(stepName);
-        step.overall_description = config["plugin_description"] || "";
-        step.action_description = config["action_description"] || "";
-        step.action_type = config["action_type"] || "";
-        step.secrets = config["secrets"] || [];
-        step.inputs = config["inputs"] || [];
-        step.outputs = config["outputs"] || [];
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        step.name = config.name || stepName;
+        step.action_step_api_name = resolveApiName(config.api_name, stepName);
+        step.overall_description = config.plugin_description || "";
+        step.action_description = config.action_description || "";
+        step.action_type = config.action_type || "";
+        step.secrets = Array.isArray(config.secrets) ? config.secrets : [];
+        step.inputs = Array.isArray(config.inputs) ? config.inputs : [];
+        step.outputs = Array.isArray(config.outputs) ? config.outputs : [];
         step.script_runtime = scriptRuntimeToApiName(
-          config["runtime"] || "python 3.12"
+          config.runtime || "python 3.12"
         );
-        step.when = config["when"] || "";
-        if (config["when"]) hasBlockingCondition = true;
+        step.when = config.when || "";
+        if (config.when) hasBlockingCondition = true;
       } else if (splitPath[2] === AUTOMATION_SCRIPT_FILE) {
         step.script = file.content;
       }
@@ -606,24 +1019,20 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!routeName) {
         continue;
       }
-      if (!routeScripts[routeName]) {
-        requiredConfigFiles[`route:${routeName}`] = true;
-        routeScripts[routeName] = {
-          script: "",
-          api_name: "",
-          hint_object_name: "",
-          routes: [],
-          name: routeName
-        };
-      }
+      routeScripts[routeName] ??= {
+        script: "",
+        api_name: "",
+        hint_object_name: "",
+        routes: [],
+        name: routeName
+      };
       const route = routeScripts[routeName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`route:${routeName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        route.api_name = config["api_name"] || sanitizeToAPIName(routeName);
-        route.hint_object_name = config["hint_object_name"] || "";
-        route.routes = config["routes"] || [];
-        route.name = config["name"] || routeName;
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        route.api_name = resolveApiName(config.api_name, routeName);
+        route.hint_object_name = config.hint_object_name || "";
+        route.routes = Array.isArray(config.routes) ? config.routes : [];
+        route.name = config.name || routeName;
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         route.script = file.minified;
       }
@@ -632,22 +1041,18 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!actionName) {
         continue;
       }
-      if (!jsActions[actionName]) {
-        requiredConfigFiles[`action:${actionName}`] = true;
-        jsActions[actionName] = {
-          script: "",
-          name: "",
-          hint_object_name: "",
-          api_name: ""
-        };
-      }
+      jsActions[actionName] ??= {
+        script: "",
+        name: "",
+        hint_object_name: "",
+        api_name: ""
+      };
       const action = jsActions[actionName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`action:${actionName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        action.name = config["name"] || actionName;
-        action.hint_object_name = config["hint_object_name"] || "";
-        action.api_name = config["api_name"] || sanitizeToAPIName(actionName);
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        action.name = config.name || actionName;
+        action.hint_object_name = config.hint_object_name || "";
+        action.api_name = resolveApiName(config.api_name, actionName);
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         action.script = file.minified;
       }
@@ -656,22 +1061,18 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!itemName) {
         continue;
       }
-      if (!objectSettingsItems[itemName]) {
-        requiredConfigFiles[`objectSettingsItem:${itemName}`] = true;
-        objectSettingsItems[itemName] = {
-          api_name: "",
-          label: "",
-          script: "",
-          when: ""
-        };
-      }
+      objectSettingsItems[itemName] ??= {
+        api_name: "",
+        label: "",
+        script: "",
+        when: ""
+      };
       const settingsItem = objectSettingsItems[itemName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`objectSettingsItem:${itemName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        settingsItem.api_name = config["api_name"] || sanitizeToAPIName(itemName);
-        settingsItem.label = config["label"] || "";
-        settingsItem.when = config["when"] || "";
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        settingsItem.api_name = resolveApiName(config.api_name, itemName);
+        settingsItem.label = config.label || "";
+        settingsItem.when = config.when || "";
       } else if (splitPath[2] === MAIN_SCRIPT_FILE) {
         settingsItem.script = file.minified;
       }
@@ -680,24 +1081,20 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!itemName) {
         continue;
       }
-      if (!calendarSources[itemName]) {
-        requiredConfigFiles[`calendarSource:${itemName}`] = true;
-        calendarSources[itemName] = {
-          api_name: "",
-          name: "",
-          calendars_script: "",
-          events_script: "",
-          when: ""
-        };
-      }
+      calendarSources[itemName] ??= {
+        api_name: "",
+        name: "",
+        calendars_script: "",
+        events_script: "",
+        when: ""
+      };
       const cal = calendarSources[itemName];
       if (splitPath[2] === CONFIG_FILE_NAME) {
-        requiredConfigFiles[`calendarSource:${itemName}`] = false;
-        const config = maybeParseConfig(file.content, file.path);
-        cal.api_name = config["api_name"] || sanitizeToAPIName(itemName);
-        cal.name = config["name"] || "";
-        cal.when = config["when"] || "";
-        if (config["when"]) hasBlockingCondition = true;
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        cal.api_name = resolveApiName(config.api_name, itemName);
+        cal.name = config.name || "";
+        cal.when = config.when || "";
+        if (config.when) hasBlockingCondition = true;
       } else if (splitPath[2] === "calendars.js") {
         cal.calendars_script = file.minified;
       } else if (splitPath[2] === "events.js") {
@@ -708,22 +1105,20 @@ var processOnePluginFromManifest = (manifest, files) => {
       if (!pageName) {
         continue;
       }
-      if (!routablePages[pageName]) {
-        routablePages[pageName] = {
-          name: pageName,
-          api_name: sanitizeToAPIName(pageName),
-          event_scripts: {},
-          script: "",
-          callback: "",
-          css: "",
-          is_toolbar_item: false,
-          toolbar_color: "",
-          toolbar_icon: "",
-          type: "html",
-          html: "",
-          iframe_url: ""
-        };
-      }
+      routablePages[pageName] ??= {
+        name: pageName,
+        api_name: sanitizeToAPIName(pageName),
+        event_scripts: {},
+        script: "",
+        callback: "",
+        css: "",
+        is_toolbar_item: false,
+        toolbar_color: "",
+        toolbar_icon: "",
+        type: "html",
+        html: "",
+        iframe_url: ""
+      };
       const page = routablePages[pageName];
       if (splitPath[2] === EVENT_SCRIPTS_DIRECTORY_NAME) {
         if (splitPath[3]?.endsWith(SCRIPT_EXTENSION)) {
@@ -731,9 +1126,9 @@ var processOnePluginFromManifest = (manifest, files) => {
           page.event_scripts[functionName] = file.minified;
         }
       } else if (splitPath[2] === CONFIG_FILE_NAME) {
-        const config = maybeParseConfig(file.content, file.path);
-        page.api_name = config["api_name"] || sanitizeToAPIName(pageName);
-        page.name = config["name"] || pageName;
+        const config = maybeParseConfig(file.content, file.path, apiName);
+        page.api_name = resolveApiName(config.api_name, pageName);
+        page.name = config.name || pageName;
       } else if (splitPath[2] === VIEW_FILE) {
         page.html = file.content;
         page.type = "html";
@@ -745,35 +1140,42 @@ var processOnePluginFromManifest = (manifest, files) => {
       }
     } else if (splitPath[0] === KZN_FILE_NAME) {
       if (!file.binaryData) {
-        throw new Error(
-          `KZN file ${file.path} does not contain binary data. Cannot proceed.`
-        );
+        throw new PluginValidationError([
+          errorIssue(
+            "structure/kzn-binary",
+            `KZN file ${file.path} does not contain binary data. Cannot proceed.`,
+            file.path,
+            apiName
+          )
+        ]);
       }
       if (kznFile) {
-        throw new Error(
-          `Multiple KZN files found for plugin ${apiName}. Only one is allowed.`
-        );
+        throw new PluginValidationError([
+          errorIssue(
+            "structure/duplicate-kzn",
+            `Multiple KZN files found for plugin ${apiName}. Only one is allowed.`,
+            file.path,
+            apiName
+          )
+        ]);
       }
       kznFile = zipToUint8Array(file.binaryData);
     } else if (THUMBNAIL_FILE_NAMES.includes(splitPath[0] ?? "")) {
       if (file.base64Image) {
         if (thumbnail) {
-          throw new Error(
-            `Multiple thumbnail files found for plugin ${apiName}. Only one is allowed.`
-          );
+          throw new PluginValidationError([
+            errorIssue(
+              "structure/duplicate-thumbnail",
+              `Multiple thumbnail files found for plugin ${apiName}. Only one is allowed.`,
+              file.path,
+              apiName
+            )
+          ]);
         }
         thumbnail = imagetoUint8Array(file.base64Image);
       }
     }
   }
-  const requiredFileKeys = Object.keys(requiredConfigFiles).filter(
-    (key) => requiredConfigFiles[key] === true
-  );
-  if (requiredFileKeys.length > 0) {
-    throw new Error(
-      `The following required files are missing for plugin ${apiName}: ${requiredFileKeys.join(" config.json, ")} config.json. Please ensure these files are present in the repository.`
-    );
-  }
   const setupAssistantContent = processSetupAssistantFromFiles(
     setupAssistantJSON,
     setupAssistantFunctions
@@ -794,26 +1196,31 @@ var processOnePluginFromManifest = (manifest, files) => {
   if (resolvedUserSetupAssistant !== void 0) {
     updatedManifest.user_setup_assistant = resolvedUserSetupAssistant;
   }
-  return {
-    [apiName]: {
-      manifest: updatedManifest,
-      thumbnail,
-      floatingFrames,
-      blocks,
-      dataAdornments,
-      toolbarItems,
-      routablePages,
-      actions: jsActions,
-      routeScripts,
-      releaseNotes: releaseNotes?.content,
-      objectSettingsMenuItems: objectSettingsItems,
-      calendarSources,
-      automationSteps,
-      kznFile
-    }
+  const packagedPlugin = {
+    manifest: updatedManifest,
+    thumbnail,
+    floatingFrames,
+    blocks,
+    dataAdornments,
+    toolbarItems,
+    routablePages,
+    actions: jsActions,
+    routeScripts,
+    objectSettingsMenuItems: objectSettingsItems,
+    calendarSources,
+    automationSteps,
+    kznFile
   };
+  if (releaseNotes?.content !== void 0) {
+    packagedPlugin.releaseNotes = releaseNotes.content;
+  }
+  return { [apiName]: packagedPlugin };
 };
 var packagePlugin = (files, manifests) => {
+  const errors = validatePackagedManifests(manifests, files).filter((i) => i.severity === "error");
+  if (errors.length > 0) {
+    throw new PluginValidationError(errors);
+  }
   const manifestArray = Array.isArray(manifests) ? manifests : [manifests];
   return manifestArray.reduce((acc, manifest) => {
     return { ...acc, ...processOnePluginFromManifest(manifest, files) };
@@ -822,12 +1229,24 @@ var packagePlugin = (files, manifests) => {
 var parseManifestFromFiles = (files) => {
   const manifestFile = files.find((f) => f.path === MANIFEST_FILE_NAME);
   if (!manifestFile) {
-    throw new Error("Missing kizen.json at the root of the plugin directory.");
+    throw new PluginValidationError([
+      errorIssue(
+        "manifest/missing",
+        `Missing ${MANIFEST_FILE_NAME} at the root of the plugin directory.`,
+        MANIFEST_FILE_NAME
+      )
+    ]);
   }
   try {
     return JSON.parse(manifestFile.content);
   } catch {
-    throw new Error("kizen.json could not be parsed.");
+    throw new PluginValidationError([
+      errorIssue(
+        "manifest/parse",
+        `${MANIFEST_FILE_NAME} could not be parsed. Is it properly formatted JSON?`,
+        MANIFEST_FILE_NAME
+      )
+    ]);
   }
 };
 
@@ -849,9 +1268,14 @@ var formatBaseConfig = (packagedPlugin) => {
       actions: (assistantConfig.actions ?? []).map((apiName) => {
         const action = actionsByApiName[apiName];
         if (!action) {
-          throw new Error(
-            `Action with API name ${apiName} not found in packaged plugin for setup assistant. Allowed actions: ${Object.keys(actionsByApiName).join(", ")}`
-          );
+          throw new PluginValidationError([
+            errorIssue(
+              "structure/setup-assistant-action-ref",
+              `Action with API name ${apiName} not found in packaged plugin for setup assistant. Allowed actions: ${Object.keys(actionsByApiName).join(", ")}`,
+              void 0,
+              packagedPlugin.manifest.api_name
+            )
+          ]);
         }
         return action;
       })
@@ -877,7 +1301,7 @@ var transformDeployablePlugin = (packagedPlugin) => {
     calendarSources,
     kznFile
   } = packagedPlugin;
-  return {
+  const deployablePlugin = {
     ...manifest,
     api_name: manifest.api_name,
     artifacts: {
@@ -894,11 +1318,14 @@ var transformDeployablePlugin = (packagedPlugin) => {
     },
     thumbnail,
     kznFile,
-    releaseNotes,
     base_config: formatBaseConfig(packagedPlugin),
     setup_assistant: void 0,
     services: manifest.services ?? []
   };
+  if (releaseNotes !== void 0) {
+    deployablePlugin.releaseNotes = releaseNotes;
+  }
+  return deployablePlugin;
 };
 
 // src/lib/crypto.ts
@@ -940,15 +1367,8 @@ var encrypt = (plaintext, publicKeyPem) => {
   };
 };
 var decrypt = (envelope, privateKeyPem) => {
-  const aesKey = (0, import_node_crypto.privateDecrypt)(
-    { key: privateKeyPem, ...OAEP },
-    Buffer.from(envelope.k, "base64")
-  );
-  const decipher = (0, import_node_crypto.createDecipheriv)(
-    "aes-256-gcm",
-    aesKey,
-    Buffer.from(envelope.iv, "base64")
-  );
+  const aesKey = (0, import_node_crypto.privateDecrypt)({ key: privateKeyPem, ...OAEP }, Buffer.from(envelope.k, "base64"));
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-gcm", aesKey, Buffer.from(envelope.iv, "base64"));
   decipher.setAuthTag(Buffer.from(envelope.tag, "base64"));
   return Buffer.concat([
     decipher.update(Buffer.from(envelope.ct, "base64")),
@@ -989,24 +1409,23 @@ var deserializeEnvelope = (value) => {
   const tagBytes = Buffer.from(envelope.tag, "base64");
   const kBytes = Buffer.from(envelope.k, "base64");
   if (ivBytes.length !== 12) {
-    throw new Error(
-      `Invalid encrypted value: iv must be 12 bytes (got ${ivBytes.length})`
-    );
+    throw new Error(`Invalid encrypted value: iv must be 12 bytes (got ${String(ivBytes.length)})`);
   }
   if (tagBytes.length !== 16) {
     throw new Error(
-      `Invalid encrypted value: tag must be 16 bytes (got ${tagBytes.length})`
+      `Invalid encrypted value: tag must be 16 bytes (got ${String(tagBytes.length)})`
     );
   }
   if (kBytes.length !== 384) {
     throw new Error(
-      `Invalid encrypted value: wrapped key must be 384 bytes (got ${kBytes.length})`
+      `Invalid encrypted value: wrapped key must be 384 bytes (got ${String(kBytes.length)})`
     );
   }
   return envelope;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  API_NAME_PATTERN,
   AUTOMATION_SCRIPT_FILE,
   AUTOMATION_STEPS_DIRECTORY_NAME,
   BLOCKS_DIRECTORY_NAME,
@@ -1017,6 +1436,8 @@ var deserializeEnvelope = (value) => {
   CRYPTO_ALG,
   CRYPTO_VERSION,
   DATA_ADORNMENTS_DIRECTORY_NAME,
+  ENVIRONMENTS,
+  ENVIRONMENT_ALIASES,
   EVENT_SCRIPTS_DIRECTORY_NAME,
   FLOATING_FRAMES_DIRECTORY_NAME,
   JS_ACTIONS_DIRECTORY_NAME,
@@ -1025,6 +1446,8 @@ var deserializeEnvelope = (value) => {
   MANIFEST_FILE_NAME,
   MESSAGE_SCRIPT_FILE,
   OBJECT_SETTINGS_ITEMS_DIRECTORY_NAME,
+  PUBLISHABLE_ENVIRONMENTS,
+  PluginValidationError,
   RELEASE_NOTES_EXTENSION,
   ROUTABLE_PAGES_DIRECTORY_NAME,
   SCRIPT_EXTENSION,
@@ -1036,6 +1459,7 @@ var deserializeEnvelope = (value) => {
   decrypt,
   deserializeEnvelope,
   encrypt,
+  errorIssue,
   generateKeypair,
   getAdornmentIcon,
   getMinimizedConfig,
@@ -1051,6 +1475,7 @@ var deserializeEnvelope = (value) => {
   thumbnailImageExtensions,
   transformDeployablePlugin,
   triggerImageExtensions,
+  validatePluginApp,
   zipToUint8Array
 });
 //# sourceMappingURL=index.cjs.map