@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-KHVTYIIX.js

@@ -0,0 +1,146 @@
+// src/incremental-stats.ts
+var SECONDS_PER_PROBE_SKIP = 3.5;
+function countByReason(probe, reason) {
+  return probe.filter((r) => r.present === null && r.failureReason === reason).length;
+}
+function computeStats(input) {
+  const present = input.probeResults.filter((r) => r.present === true);
+  const failed = input.probeResults.filter((r) => r.present === null);
+  const recycled = present.filter((r) => input.prevChunks[r.cid] == null);
+  return {
+    manifestSource: input.manifestSource,
+    manifestFetchAttempts: input.manifestFetchAttempts,
+    manifestBytes: input.manifestBytes ?? 0,
+    framework: input.framework,
+    filesTotal: input.filesTotal,
+    filesStable: input.filesStable,
+    filesVolatile: input.filesVolatile,
+    probedTotal: input.probeResults.length,
+    probePresent: present.length,
+    probeAbsent: input.probeResults.filter((r) => r.present === false).length,
+    probeFailed: failed.length,
+    probeFailedRpc: countByReason(input.probeResults, "rpc_error"),
+    probeFailedDecode: countByReason(input.probeResults, "decode_error"),
+    probeFailedMetadata: countByReason(input.probeResults, "metadata_error"),
+    recycledCids: recycled.length,
+    retentionPeriodBlocks: input.retentionPeriodBlocks,
+    bytesProbePresent: input.bytesProbePresent,
+    bytesProbeAbsent: input.bytesProbeAbsent ?? 0,
+    bytesSkipped: input.bytesSkipped,
+    bytesUploaded: input.bytesUploaded,
+    chunksTotal: input.chunksTotal,
+    chunksUploaded: input.chunksUploaded,
+    chunksSkipped: input.chunksSkipped,
+    carBytes: input.carBytes,
+    section0Bytes: input.sectionSizes.section0,
+    section1Bytes: input.sectionSizes.section1,
+    section2Bytes: input.sectionSizes.section2,
+    estimatedSecondsSaved: Math.round(SECONDS_PER_PROBE_SKIP * present.length),
+    tier2VerifiedCount: input.tier2VerifiedCount,
+    tier2InconclusiveCount: input.tier2InconclusiveCount,
+    tier2FallbackCount: input.tier2FallbackCount
+  };
+}
+function telemetryAttributes(s) {
+  const hitRate = s.filesTotal === 0 ? 0 : s.filesStable / s.filesTotal;
+  return {
+    "deploy.cache.manifest_source": s.manifestSource,
+    "deploy.cache.manifest_fetch_attempts": String(s.manifestFetchAttempts),
+    "deploy.cache.manifest_bytes": String(s.manifestBytes),
+    "deploy.cache.framework": s.framework ?? "",
+    "deploy.cache.hit_rate": String(Math.round(hitRate * 1e3) / 1e3),
+    "deploy.cache.files_total": String(s.filesTotal),
+    "deploy.cache.files_stable": String(s.filesStable),
+    "deploy.cache.files_volatile": String(s.filesVolatile),
+    "deploy.cache.probed_total": String(s.probedTotal),
+    "deploy.cache.probe_present": String(s.probePresent),
+    "deploy.cache.probe_absent": String(s.probeAbsent),
+    "deploy.cache.probe_failed": String(s.probeFailed),
+    "deploy.cache.probe_failed_rpc": String(s.probeFailedRpc),
+    "deploy.cache.probe_failed_decode": String(s.probeFailedDecode),
+    "deploy.cache.probe_failed_metadata": String(s.probeFailedMetadata),
+    "deploy.cache.recycled_cids": String(s.recycledCids),
+    "deploy.cache.retention_period_blocks": String(s.retentionPeriodBlocks),
+    "deploy.cache.chunks_total": String(s.chunksTotal),
+    "deploy.cache.chunks_uploaded": String(s.chunksUploaded),
+    "deploy.cache.chunks_skipped": String(s.chunksSkipped),
+    "deploy.cache.bytes_probe_present": String(s.bytesProbePresent),
+    "deploy.cache.bytes_probe_absent": String(s.bytesProbeAbsent),
+    "deploy.cache.bytes_skipped": String(s.bytesSkipped),
+    "deploy.cache.bytes_uploaded": String(s.bytesUploaded),
+    "deploy.cache.car_bytes": String(s.carBytes),
+    "deploy.cache.section0_bytes": String(s.section0Bytes),
+    "deploy.cache.section1_bytes": String(s.section1Bytes),
+    "deploy.cache.section2_bytes": String(s.section2Bytes),
+    "deploy.cache.estimated_seconds_saved": String(s.estimatedSecondsSaved),
+    "deploy.cache.tier2_fallback": String(s.tier2FallbackCount),
+    "deploy.cache.tier2_verified": String(s.tier2VerifiedCount),
+    "deploy.cache.tier2_inconclusive": String(s.tier2InconclusiveCount)
+  };
+}
+function fmtMb(bytes) {
+  return (bytes / 1e6).toFixed(1);
+}
+function fmtKb(bytes) {
+  return (bytes / 1e3).toFixed(1);
+}
+function renderSummary(s) {
+  const lines = [];
+  const attemptsWord = s.manifestFetchAttempts === 1 ? "attempt" : "attempts";
+  if (s.manifestSource === "heuristic_fallback") {
+    lines.push(`  \u26A0 Previous manifest fetch failed after ${s.manifestFetchAttempts} ${attemptsWord} (gateway timeout).`);
+    lines.push(`    Using heuristic classification \u2014 hit rate may be lower this run.`);
+    lines.push(`    Subsequent deploys recover automatically.`);
+    lines.push("");
+  }
+  lines.push(`Cache:`);
+  if (s.manifestSource === "none") {
+    lines.push(`  Manifest:      first deploy (no previous manifest)`);
+  } else if (s.manifestSource === "embedded") {
+    const sizeStr = s.manifestBytes > 0 ? `, ${fmtKb(s.manifestBytes)} KB Range hit` : "";
+    lines.push(`  Manifest:      embedded (${s.manifestFetchAttempts} ${attemptsWord}${sizeStr})`);
+  } else {
+    lines.push(`  Manifest:      heuristic_fallback (${s.manifestFetchAttempts} ${attemptsWord})`);
+  }
+  if (s.filesTotal > 0 && s.manifestSource !== "none") {
+    const pct = s.filesTotal === 0 ? 0 : Math.round(s.filesStable / s.filesTotal * 100);
+    const heuristicNote = s.manifestSource === "heuristic_fallback" ? " (heuristic estimate)" : "";
+    lines.push(`  Files:         ${s.filesStable} unchanged, ${s.filesVolatile} changed (${pct} % stable)${heuristicNote}`);
+  }
+  if (s.probedTotal > 0) {
+    let probeFailedStr = "";
+    if (s.probeFailed > 0) {
+      const reasons = [];
+      if (s.probeFailedRpc > 0) reasons.push("rpc_error");
+      if (s.probeFailedDecode > 0) reasons.push("decode_error");
+      if (s.probeFailedMetadata > 0) reasons.push("metadata_error");
+      probeFailedStr = `, ${s.probeFailed} probe-failed (${reasons.join(", ")})`;
+    }
+    lines.push(`  Probed:        ${s.probedTotal} chunks  \u2192  ${s.probePresent} on chain, ${s.probeAbsent} absent${probeFailedStr}`);
+  }
+  if (s.recycledCids > 0 && s.manifestSource === "embedded") {
+    lines.push(`  Recycled:      ${s.recycledCids} CIDs found on-chain that weren't in the previous manifest`);
+  }
+  if (s.tier2FallbackCount > 0) {
+    const inconclusiveStr = s.tier2InconclusiveCount > 0 ? `, ${s.tier2InconclusiveCount} inconclusive` : "";
+    lines.push(`  Verify:        ${s.tier2VerifiedCount}/${s.tier2FallbackCount} via-fallback chunks confirmed on chain${inconclusiveStr}`);
+  }
+  lines.push(`  CAR sections:  manifest ${fmtKb(s.section0Bytes)} KB \xB7 stable ${fmtMb(s.section1Bytes)} MB \xB7 volatile ${fmtMb(s.section2Bytes)} MB`);
+  if (s.chunksUploaded > 0) {
+    if (s.bytesSkipped > 0) {
+      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks (vs ${fmtMb(s.carBytes)} MB if full deploy)`);
+    } else {
+      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks`);
+    }
+  }
+  if (s.estimatedSecondsSaved > 0 || s.bytesSkipped > 0) {
+    lines.push(`  Saved:         ~${s.estimatedSecondsSaved} s and ${fmtMb(s.bytesSkipped)} MB`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  computeStats,
+  telemetryAttributes,
+  renderSummary
+};

package/dist/chunk-KJH2T5TQ.js

@@ -0,0 +1,172 @@
+// src/run-state.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+// package.json
+var package_default = {
+  name: "@parity/product-deploy",
+  version: "0.7.28-rc.0",
+  private: false,
+  repository: {
+    type: "git",
+    url: "https://github.com/paritytech/bulletin-deploy.git"
+  },
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    "bulletin-deploy": "./bin/bulletin-deploy",
+    "bulletin-bootstrap": "./bin/bulletin-bootstrap"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./deploy": {
+      types: "./dist/deploy.d.ts",
+      import: "./dist/deploy.js"
+    },
+    "./manifest-roundtrip": {
+      types: "./dist/manifest-roundtrip.d.ts",
+      import: "./dist/manifest-roundtrip.js"
+    }
+  },
+  files: [
+    "dist",
+    "bin",
+    "docs",
+    "assets",
+    "tools/release-retry-wrapper.mjs"
+  ],
+  scripts: {
+    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/memory-report.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts src/run-state.ts src/environments.ts src/errors.ts src/manifest.ts src/chunk-probe.ts src/manifest-embed.ts src/manifest-fetch.ts src/manifest-roundtrip.ts src/incremental-stats.ts src/chunker.ts src/personhood/encoding.ts src/personhood/hashing.ts src/personhood/constants.ts src/personhood/member-key.ts src/personhood/people-client.ts src/personhood/reprove.ts src/personhood/bind-personal-id.ts src/personhood/claim-pgas.ts src/personhood/bind-paid-alias.ts src/personhood/bootstrap.ts src/manifest/types.ts src/manifest/schema.ts src/manifest/byte-budget.ts src/manifest/config-load.ts src/manifest/publish.ts --format esm --dts --clean --target node22",
+    "refresh-environments": "node scripts/refresh-environments.mjs",
+    "check:watched-dependencies": "node tools/check-watched-dependencies.mjs",
+    prepare: "npm run build",
+    test: "npm run build && node --test test/test.js test/cli-help.test.js test/helpers/e2e-helpers.test.js test/environments.test.js test/refresh-environments.test.js test/watched-dependencies.test.js test/chunk-sharing-report.test.js test/product-manifest.test.js",
+    "test:e2e": "npm run build && node --test test/e2e.test.js",
+    "test:e2e:smoke": "bash scripts/e2e-pass.sh smoke",
+    "test:e2e:pr": "bash scripts/e2e-pass.sh pr",
+    "test:e2e:nightly": "bash scripts/e2e-pass.sh nightly",
+    benchmark: "npm run build && node benchmark.js"
+  },
+  dependencies: {
+    "@ipld/car": "^5.4.3",
+    "@ipld/dag-pb": "^4.1.3",
+    "@noble/hashes": "^1.7.2",
+    "@polkadot-api/metadata-builders": "^0.14.2",
+    "@polkadot-api/substrate-bindings": "^0.20.2",
+    "@polkadot-labs/hdkd": "^0.0.28",
+    "@polkadot-labs/hdkd-helpers": "^0.0.30",
+    "@polkadot/keyring": "^14.0.3",
+    "@polkadot/util-crypto": "^14.0.3",
+    "@sentry/node": "^9.14.0",
+    "ipfs-unixfs": "^11.2.0",
+    "ipfs-unixfs-importer": "^16.1.4",
+    jiti: "^2.4.2",
+    multiformats: "^13.4.1",
+    "polkadot-api": "^2.1.3",
+    verifiablejs: "^1.2.0",
+    viem: "^2.30.5"
+  },
+  devDependencies: {
+    "@types/node": "^22.0.0",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3",
+    ws: "^8.20.1"
+  },
+  minimumVersion: "0.5.6",
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/run-state.ts
+var VERSION = package_default.version;
+function resolveStateDir() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "bulletin-deploy");
+  }
+  if (process.platform === "win32") {
+    const base2 = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+    return path.join(base2, "bulletin-deploy");
+  }
+  const base = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.length > 0 ? process.env.XDG_STATE_HOME : path.join(os.homedir(), ".local", "state");
+  return path.join(base, "bulletin-deploy");
+}
+function stateFilePath() {
+  return path.join(resolveStateDir(), "last-run.json");
+}
+function loadRunState() {
+  try {
+    const raw = fs.readFileSync(stateFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeRunState(patch) {
+  try {
+    const dir = resolveStateDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = stateFilePath();
+    let existing = {};
+    try {
+      const raw = fs.readFileSync(file, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") existing = parsed;
+    } catch {
+    }
+    const merged = { ...existing, ...patch };
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(merged), { encoding: "utf-8" });
+    fs.renameSync(tmp, file);
+  } catch {
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+function shouldSkipStaleWarning(prev) {
+  if (prev.pid && isPidAlive(prev.pid)) return true;
+  if (prev.toolVersion !== VERSION) return true;
+  return false;
+}
+function probablyOomRssMb(override) {
+  if (typeof override === "number" && Number.isFinite(override)) return override;
+  const env = process.env.BULLETIN_DEPLOY_OOM_HINT_RSS_MB;
+  const parsed = env != null ? Number(env) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return 1800;
+}
+function shouldShowOomHint(prev) {
+  if (prev.lastPeakRssMb == null) return false;
+  return prev.lastPeakRssMb >= probablyOomRssMb();
+}
+
+export {
+  package_default,
+  VERSION,
+  resolveStateDir,
+  stateFilePath,
+  loadRunState,
+  writeRunState,
+  shouldSkipStaleWarning,
+  probablyOomRssMb,
+  shouldShowOomHint
+};

package/dist/chunk-KOSF5FDO.js

@@ -0,0 +1,49 @@
+import {
+  MANIFEST_DIR,
+  MANIFEST_PATH
+} from "./chunk-S7EM5VMW.js";
+
+// src/manifest-embed.ts
+import * as fs from "fs";
+import * as path from "path";
+function writeAtomic(filePath, body) {
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, body);
+  fs.renameSync(tmp, filePath);
+}
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+function writeEmbeddedManifestPlaceholder(buildDir, data) {
+  ensureDir(path.join(buildDir, MANIFEST_DIR));
+  const payload = {
+    version: data.version,
+    previous_contenthash: data.previousContenthash,
+    deployed_at: data.deployedAt,
+    framework: data.framework,
+    files: {},
+    stableBlockOrder: [],
+    blocks: [],
+    chunks: {}
+  };
+  writeAtomic(path.join(buildDir, MANIFEST_PATH), JSON.stringify(payload, null, 2));
+}
+function finaliseEmbeddedManifest(buildDir, data) {
+  ensureDir(path.join(buildDir, MANIFEST_DIR));
+  const payload = {
+    version: data.version,
+    previous_contenthash: data.previousContenthash,
+    deployed_at: data.deployedAt,
+    framework: data.framework,
+    files: data.files,
+    stableBlockOrder: data.stableBlockOrder,
+    blocks: data.blocks,
+    chunks: data.chunks
+  };
+  writeAtomic(path.join(buildDir, MANIFEST_PATH), JSON.stringify(payload, null, 2));
+}
+
+export {
+  writeEmbeddedManifestPlaceholder,
+  finaliseEmbeddedManifest
+};

package/dist/chunk-LZJMVPYW.js

@@ -0,0 +1,156 @@
+// src/manifest/schema.ts
+var ICON_FORMATS = ["jpeg", "png"];
+var KIND_APP = "app";
+var KIND_WIDGET = "widget";
+var KIND_WORKER = "worker";
+var EXECUTABLE_KINDS = [KIND_APP, KIND_WIDGET, KIND_WORKER];
+var LABEL = String.raw`(?!-)[a-z0-9-]{1,63}(?<!-)`;
+var DOMAIN_RE = new RegExp(`^${LABEL}(\\.${LABEL})*\\.dot$`, "i");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isAppVersion(value) {
+  if (!Array.isArray(value)) return false;
+  if (value.length !== 3 && value.length !== 4) return false;
+  if (!value.slice(0, 3).every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0)) {
+    return false;
+  }
+  if (value.length === 4 && typeof value[3] !== "string") return false;
+  return true;
+}
+function validateWidgetFields(input, p) {
+  const errors = [];
+  if ("description" in input && input.description !== void 0 && typeof input.description !== "string") {
+    errors.push(`${p}description must be a string when present`);
+  }
+  if (!isPlainObject(input.dimensions)) {
+    errors.push(`${p}dimensions must be an object`);
+    return errors;
+  }
+  const dims = input.dimensions;
+  if (!Array.isArray(dims.height) || dims.height.length === 0 || !dims.height.every((h) => typeof h === "number" && Number.isInteger(h) && h > 0)) {
+    errors.push(`${p}dimensions.height must be a non-empty array of positive integers`);
+  }
+  if ("width" in dims && dims.width !== void 0 && !(typeof dims.width === "number" && Number.isInteger(dims.width) && dims.width > 0)) {
+    errors.push(`${p}dimensions.width must be a positive integer when present`);
+  }
+  return errors;
+}
+function validateWorkerFields(input, p) {
+  const errors = [];
+  if (!isNonEmptyString(input.entrypoint)) {
+    errors.push(`${p}entrypoint must be a non-empty string`);
+  } else if (input.entrypoint.startsWith("/") || input.entrypoint.split("/").includes("..")) {
+    errors.push(`${p}entrypoint must be a relative path with no '..' segments`);
+  }
+  if (!isPlainObject(input.includes)) {
+    errors.push(`${p}includes must be an object`);
+    return errors;
+  }
+  const inc = input.includes;
+  if (typeof inc.chat !== "boolean") errors.push(`${p}includes.chat must be a boolean`);
+  if (typeof inc.pocket !== "boolean") errors.push(`${p}includes.pocket must be a boolean`);
+  if (inc.chat === false && inc.pocket === false) {
+    errors.push(`${p}includes must have at least one of chat / pocket = true`);
+  }
+  return errors;
+}
+function validateRootManifest(input) {
+  const errors = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["root manifest must be an object"] };
+  }
+  if (input.$v !== 1) errors.push(`root manifest $v must be 1 (got ${JSON.stringify(input.$v)})`);
+  if (!isNonEmptyString(input.displayName)) errors.push("root manifest displayName must be a non-empty string");
+  if (typeof input.description !== "string") errors.push("root manifest description must be a string");
+  if (!isPlainObject(input.icon)) {
+    errors.push("root manifest icon must be an object");
+  } else {
+    if (!isNonEmptyString(input.icon.cid)) errors.push("root manifest icon.cid must be a non-empty string");
+    if (!ICON_FORMATS.includes(input.icon.format)) {
+      errors.push(`root manifest icon.format must be one of ${ICON_FORMATS.join(", ")} (got ${JSON.stringify(input.icon.format)})`);
+    }
+  }
+  return errors.length === 0 ? { ok: true, value: input } : { ok: false, errors };
+}
+function validateExecutableManifest(input) {
+  const errors = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["executable manifest must be an object"] };
+  }
+  if (input.$v !== 1) errors.push(`executable manifest $v must be 1 (got ${JSON.stringify(input.$v)})`);
+  if (!isAppVersion(input.appVersion)) {
+    errors.push("executable manifest appVersion must be [major, minor, patch] or [major, minor, patch, build]");
+  }
+  const kind = input.kind;
+  const p = "executable manifest ";
+  if (kind === KIND_APP) {
+  } else if (kind === KIND_WIDGET) {
+    errors.push(...validateWidgetFields(input, p));
+  } else if (kind === KIND_WORKER) {
+    errors.push(...validateWorkerFields(input, p));
+  } else {
+    errors.push(`${p}kind must be one of ${EXECUTABLE_KINDS.join(", ")} (got ${JSON.stringify(kind)})`);
+  }
+  return errors.length === 0 ? { ok: true, value: input } : { ok: false, errors };
+}
+function validateProductConfig(input) {
+  const errors = [];
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["product config must be an object (did you forget `export default`?)"] };
+  }
+  if (!isNonEmptyString(input.domain) || !DOMAIN_RE.test(input.domain)) {
+    errors.push("product config domain must be a non-empty dotNS name ending in .dot");
+  }
+  if (!isNonEmptyString(input.displayName)) errors.push("product config displayName must be a non-empty string");
+  if (typeof input.description !== "string") errors.push("product config description must be a string");
+  if (!isPlainObject(input.icon)) {
+    errors.push("product config icon must be an object");
+  } else {
+    if (!isNonEmptyString(input.icon.path)) errors.push("product config icon.path must be a non-empty string");
+    if (!ICON_FORMATS.includes(input.icon.format)) {
+      errors.push(`product config icon.format must be one of ${ICON_FORMATS.join(", ")}`);
+    }
+  }
+  if (!Array.isArray(input.executables) || input.executables.length === 0) {
+    errors.push("product config executables must be a non-empty array");
+  } else {
+    const seenKinds = /* @__PURE__ */ new Set();
+    input.executables.forEach((exec, index) => {
+      errors.push(...validateExecutableConfig(exec, index));
+      if (isPlainObject(exec) && typeof exec.kind === "string") {
+        if (seenKinds.has(exec.kind)) errors.push(`executables[${index}]: duplicate kind '${exec.kind}'`);
+        seenKinds.add(exec.kind);
+      }
+    });
+  }
+  return errors.length === 0 ? { ok: true, value: input } : { ok: false, errors };
+}
+function validateExecutableConfig(input, index) {
+  const p = `executables[${index}].`;
+  if (!isPlainObject(input)) return [`executables[${index}] must be an object`];
+  const errors = [];
+  if (!isNonEmptyString(input.path)) errors.push(`${p}path must be a non-empty string`);
+  if (!isAppVersion(input.appVersion)) {
+    errors.push(`${p}appVersion must be [major, minor, patch] or [major, minor, patch, build]`);
+  }
+  const kind = input.kind;
+  if (kind === KIND_APP) {
+  } else if (kind === KIND_WIDGET) {
+    errors.push(...validateWidgetFields(input, p));
+  } else if (kind === KIND_WORKER) {
+    errors.push(...validateWorkerFields(input, p));
+  } else {
+    errors.push(`${p}kind must be one of ${EXECUTABLE_KINDS.join(", ")} (got ${JSON.stringify(kind)})`);
+  }
+  return errors;
+}
+
+export {
+  validateRootManifest,
+  validateExecutableManifest,
+  validateProductConfig
+};