@penvhq/launcher 0.9.0

package/dist/index.cjs

@@ -0,0 +1,1628 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddFlagError: () => AddFlagError,
+  AddNoDownloadError: () => AddNoDownloadError,
+  AddNotInteractiveError: () => AddNotInteractiveError,
+  AddPackageNameError: () => AddPackageNameError,
+  AddRegistryError: () => AddRegistryError,
+  AddSubjectError: () => AddSubjectError,
+  ArchiveError: () => ArchiveError,
+  BUNDLED_ENGINE_PIN: () => BUNDLED_ENGINE_PIN,
+  DEFAULT_REGISTRY: () => DEFAULT_REGISTRY,
+  DEV_PIN_INTEGRITY: () => DEV_PIN_INTEGRITY,
+  DEV_PIN_VERSION: () => DEV_PIN_VERSION,
+  DeclarationMissingError: () => DeclarationMissingError,
+  DeclarationNotSelfContainedError: () => DeclarationNotSelfContainedError,
+  DownloadFailedError: () => DownloadFailedError,
+  DownloadIntegrityError: () => DownloadIntegrityError,
+  ENGINE_BIN: () => ENGINE_BIN,
+  EngineEntryError: () => EngineEntryError,
+  EnginePinMismatchError: () => EnginePinMismatchError,
+  EnginePinUnreleasedError: () => EnginePinUnreleasedError,
+  HOME_META_FILE: () => HOME_META_FILE,
+  INSTALL_COMMAND: () => INSTALL_COMMAND,
+  INTEGRITY_FILE: () => INTEGRITY_FILE,
+  InstallDeclinedError: () => InstallDeclinedError,
+  MIN_PACKAGE_AGE_DAYS: () => MIN_PACKAGE_AGE_DAYS,
+  NPM_UPDATE_COMMAND: () => NPM_UPDATE_COMMAND,
+  NoProjectError: () => NoProjectError,
+  OfficialRegistryError: () => OfficialRegistryError,
+  PENV_HOME_VAR: () => PENV_HOME_VAR,
+  PackageCorruptError: () => PackageCorruptError,
+  PackageMissingError: () => PackageMissingError,
+  PackageTooYoungError: () => PackageTooYoungError,
+  PackageUnknownError: () => PackageUnknownError,
+  RegistryUnreadableError: () => RegistryUnreadableError,
+  ReleaseIncompleteError: () => ReleaseIncompleteError,
+  TRUST_YOUNG_FLAG: () => TRUST_YOUNG_FLAG,
+  TrustDeclinedError: () => TrustDeclinedError,
+  TrustPublisherMissingError: () => TrustPublisherMissingError,
+  TrustReasonMissingError: () => TrustReasonMissingError,
+  VersionUnknownError: () => VersionUnknownError,
+  add: () => add,
+  assertReleasePin: () => assertReleasePin,
+  bundledEngine: () => bundledEngine,
+  declarationPath: () => declarationPath,
+  engineAt: () => engineAt,
+  fetchRelease: () => fetchRelease,
+  findAdoptedRoot: () => findAdoptedRoot,
+  findProject: () => findProject,
+  httpFetcher: () => httpFetcher,
+  inspectInstall: () => inspectInstall,
+  installPin: () => installPin,
+  integrityOf: () => integrityOf,
+  launcherUpdateCommand: () => launcherUpdateCommand,
+  nodeSpawner: () => nodeSpawner,
+  packageDir: () => packageDir,
+  packumentUrl: () => packumentUrl,
+  penvHome: () => penvHome,
+  readExtensionPackage: () => readExtensionPackage,
+  readProviderEntries: () => readProviderEntries,
+  readTarball: () => readTarball,
+  releaseEnginePin: () => releaseEnginePin,
+  renderDeclaration: () => renderDeclaration,
+  runLauncher: () => runLauncher,
+  setProviderType: () => setProviderType,
+  tarballUrl: () => tarballUrl,
+  writeDeclaration: () => writeDeclaration
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/add.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var import_core5 = require("@penvhq/core");
+
+// src/config-edit.ts
+var QUOTES = /* @__PURE__ */ new Set(['"', "'", "`"]);
+function skipTrivia(source, index) {
+  let i = index;
+  for (; ; ) {
+    const ch = source.charAt(i);
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && source.charAt(i + 1) === "/") {
+      const end = source.indexOf("\n", i);
+      i = end === -1 ? source.length : end + 1;
+      continue;
+    }
+    if (ch === "/" && source.charAt(i + 1) === "*") {
+      const end = source.indexOf("*/", i + 2);
+      i = end === -1 ? source.length : end + 2;
+      continue;
+    }
+    return i;
+  }
+}
+function skipString(source, index) {
+  const quote = source.charAt(index);
+  let i = index + 1;
+  while (i < source.length) {
+    const ch = source.charAt(i);
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return i + 1;
+    }
+    i += 1;
+  }
+  return source.length;
+}
+function matchBrace(source, open) {
+  let depth = 0;
+  let i = open;
+  while (i < source.length) {
+    const ch = source.charAt(i);
+    if (QUOTES.has(ch)) {
+      i = skipString(source, i);
+      continue;
+    }
+    const skipped = skipTrivia(source, i);
+    if (skipped !== i) {
+      i = skipped;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth += 1;
+    } else if (ch === "}" || ch === "]" || ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        return i + 1;
+      }
+    }
+    i += 1;
+  }
+  return -1;
+}
+function readKey(source, index) {
+  const ch = source.charAt(index);
+  if (ch === '"' || ch === "'") {
+    const end = skipString(source, index);
+    return { key: source.slice(index + 1, end - 1), end };
+  }
+  const match = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(source.slice(index));
+  return match === null ? void 0 : { key: match[0], end: index + match[0].length };
+}
+function typeSlotIn(source, open, close) {
+  let i = skipTrivia(source, open + 1);
+  while (i < close - 1) {
+    const key = readKey(source, i);
+    if (key === void 0) {
+      return void 0;
+    }
+    const colon = skipTrivia(source, key.end);
+    if (source.charAt(colon) !== ":") {
+      return void 0;
+    }
+    const valueStart = skipTrivia(source, colon + 1);
+    const ch = source.charAt(valueStart);
+    let valueEnd;
+    if (QUOTES.has(ch)) {
+      valueEnd = skipString(source, valueStart);
+      if (key.key === "type" && ch !== "`") {
+        return {
+          start: valueStart,
+          end: valueEnd,
+          value: source.slice(valueStart + 1, valueEnd - 1)
+        };
+      }
+    } else if (ch === "{" || ch === "[" || ch === "(") {
+      valueEnd = matchBrace(source, valueStart);
+      if (valueEnd === -1) {
+        return void 0;
+      }
+    } else {
+      const comma = /[,}]/.exec(source.slice(valueStart));
+      valueEnd = comma === null ? close - 1 : valueStart + comma.index;
+    }
+    i = skipTrivia(source, valueEnd);
+    if (source.charAt(i) === ",") {
+      i = skipTrivia(source, i + 1);
+    }
+  }
+  return void 0;
+}
+function scan(source) {
+  const found = /(?:^|[\s{,;])providers\s*:\s*\{/.exec(source);
+  if (found === null) {
+    return void 0;
+  }
+  const open = found.index + found[0].length - 1;
+  const close = matchBrace(source, open);
+  if (close === -1) {
+    return void 0;
+  }
+  const entries = [];
+  let i = skipTrivia(source, open + 1);
+  while (i < close - 1) {
+    const key = readKey(source, i);
+    if (key === void 0) {
+      return void 0;
+    }
+    const colon = skipTrivia(source, key.end);
+    if (source.charAt(colon) !== ":") {
+      return void 0;
+    }
+    const entryOpen = skipTrivia(source, colon + 1);
+    if (source.charAt(entryOpen) !== "{") {
+      return void 0;
+    }
+    const entryClose = matchBrace(source, entryOpen);
+    if (entryClose === -1) {
+      return void 0;
+    }
+    const slot = typeSlotIn(source, entryOpen, entryClose);
+    entries.push({ environment: key.key, type: slot?.value, slot });
+    i = skipTrivia(source, entryClose);
+    if (source.charAt(i) === ",") {
+      i = skipTrivia(source, i + 1);
+    }
+  }
+  return entries;
+}
+function readProviderEntries(source) {
+  return scan(source)?.map(({ environment, type }) => ({ environment, type }));
+}
+function setProviderType(source, environment, type) {
+  const entry = scan(source)?.find((candidate) => candidate.environment === environment);
+  if (entry?.slot === void 0) {
+    return void 0;
+  }
+  return `${source.slice(0, entry.slot.start)}${JSON.stringify(type)}${source.slice(entry.slot.end)}`;
+}
+
+// src/declaration.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_core2 = require("@penvhq/core");
+
+// src/errors.ts
+var import_core = require("@penvhq/core");
+var INSTALL_COMMAND = "penv install";
+var MIN_PACKAGE_AGE_DAYS = 7;
+var TRUST_YOUNG_FLAG = "--trust-young";
+function addCommand(name, version, extra) {
+  const spec = version === void 0 ? name : `${name}@${version}`;
+  return `penv add ${spec}${extra === void 0 ? "" : ` ${extra}`}`;
+}
+var NoProjectError = class extends import_core.PenvError {
+  name = "NoProjectError";
+  constructor(cwd) {
+    super(
+      "PENV_NO_PROJECT",
+      `penv found no ${import_core.MANIFEST_PATH} in ${cwd} or any parent directory`,
+      "Run `penv init` here to adopt this project."
+    );
+  }
+};
+var PackageMissingError = class extends import_core.PenvError {
+  name = "PackageMissingError";
+  constructor(name, version, home) {
+    super(
+      "PENV_PACKAGE_MISSING",
+      `${name} ${version} is not installed in ${home}, and this run does not download`,
+      `Run \`${INSTALL_COMMAND}\` \u2014 CI and production install the versions the manifest pins before the command that needs them.`
+    );
+  }
+};
+var PackageCorruptError = class extends import_core.PenvError {
+  name = "PackageCorruptError";
+  constructor(name, version, dir) {
+    super(
+      "PENV_PACKAGE_CORRUPT",
+      `${name} ${version} in ${dir} is not the bytes ${import_core.MANIFEST_PATH} pins`,
+      `Delete ${dir} and run \`${INSTALL_COMMAND}\` \u2014 penv runs the exact bytes the manifest names, or nothing.`
+    );
+  }
+};
+var InstallDeclinedError = class extends import_core.PenvError {
+  name = "InstallDeclinedError";
+  constructor(name, version) {
+    super(
+      "PENV_INSTALL_DECLINED",
+      `${name} ${version} was not downloaded`,
+      `Run \`${INSTALL_COMMAND}\` when you want penv to fetch the versions this project pins.`
+    );
+  }
+};
+var DownloadFailedError = class extends import_core.PenvError {
+  name = "DownloadFailedError";
+  constructor(name, version, url, detail) {
+    super(
+      "PENV_DOWNLOAD_FAILED",
+      `Downloading ${name} ${version} from ${url} failed: ${detail}`,
+      `Run \`${INSTALL_COMMAND}\` again when the registry is reachable.`
+    );
+  }
+};
+var DownloadIntegrityError = class extends import_core.PenvError {
+  name = "DownloadIntegrityError";
+  constructor(name, version, url) {
+    super(
+      "PENV_DOWNLOAD_INTEGRITY",
+      `${name} ${version} from ${url} is not the bytes ${import_core.MANIFEST_PATH} pins`,
+      `Check the registry \u2014 the bytes it served are not the ones the pin was reviewed against, so penv installed nothing.`
+    );
+  }
+};
+var ArchiveError = class extends import_core.PenvError {
+  name = "ArchiveError";
+  constructor(name, version, entry) {
+    super(
+      "PENV_ARCHIVE",
+      `The ${name} ${version} archive holds \`${entry}\`, which penv will not extract`,
+      "Check the registry \u2014 penv extracts regular files under `package/` and nothing else."
+    );
+  }
+};
+var AddSubjectError = class extends import_core.PenvError {
+  name = "AddSubjectError";
+  constructor() {
+    super(
+      "PENV_ADD_SUBJECT",
+      "`penv add` names no package",
+      "Run `penv add @penvhq/provider-vault`, or any provider package name \u2014 optionally with `@<version>` to pin one other than the latest."
+    );
+  }
+};
+var AddPackageNameError = class extends import_core.PenvError {
+  name = "AddPackageNameError";
+  constructor(spec) {
+    super(
+      "PENV_ADD_PACKAGE_NAME",
+      `\`${spec}\` is not an npm package name`,
+      "Name the package exactly as npm does, e.g. `penv add @acme/provider-consul@1.4.2`."
+    );
+  }
+};
+var AddFlagError = class extends import_core.PenvError {
+  name = "AddFlagError";
+  constructor(flag) {
+    super(
+      "PENV_ADD_FLAG",
+      `\`penv add\` does not understand \`${flag}\``,
+      `Run \`penv add <package>\` with \`${TRUST_YOUNG_FLAG}\` or \`--registry <url>\` \u2014 those are the two it takes.`
+    );
+  }
+};
+var AddRegistryError = class extends import_core.PenvError {
+  name = "AddRegistryError";
+  constructor(value) {
+    super(
+      "PENV_ADD_REGISTRY",
+      `\`--registry ${value}\` is not an https URL`,
+      "Write the registry's origin, e.g. `--registry https://npm.acme.internal`. Over plain http the integrity check proves only that you got the bytes an attacker on the network chose."
+    );
+  }
+};
+var OfficialRegistryError = class extends import_core.PenvError {
+  name = "OfficialRegistryError";
+  constructor(name, registry) {
+    super(
+      "PENV_OFFICIAL_REGISTRY",
+      `${name} was asked for from ${registry}, and \`${import_core.OFFICIAL_SCOPE}*\` packages come from npmjs`,
+      `Run \`${addCommand(name)}\` without \`--registry\`. The official scope is the one penv adds without a trust question, so penv will not take it from somewhere else.`
+    );
+  }
+};
+var RegistryUnreadableError = class extends import_core.PenvError {
+  name = "RegistryUnreadableError";
+  constructor(name, url, detail) {
+    super(
+      "PENV_REGISTRY_UNREADABLE",
+      `Reading ${name} from ${url} failed: ${detail}`,
+      `Run \`${addCommand(name)}\` again when the registry is reachable.`
+    );
+  }
+};
+var PackageUnknownError = class extends import_core.PenvError {
+  name = "PackageUnknownError";
+  constructor(name, url) {
+    super(
+      "PENV_PACKAGE_UNKNOWN",
+      `${url} publishes no versions of ${name}`,
+      "Check the package name against the registry \u2014 penv adds a package that exists or nothing."
+    );
+  }
+};
+var VersionUnknownError = class extends import_core.PenvError {
+  name = "VersionUnknownError";
+  constructor(name, version, url) {
+    super(
+      "PENV_VERSION_UNKNOWN",
+      `${url} publishes no ${version} of ${name}`,
+      `Run \`${addCommand(name)}\` to take the version \`latest\` points at.`
+    );
+  }
+};
+var ReleaseIncompleteError = class extends import_core.PenvError {
+  name = "ReleaseIncompleteError";
+  constructor(name, version, url, missing) {
+    super(
+      "PENV_RELEASE_INCOMPLETE",
+      `${url} records no ${missing} for ${name} ${version}`,
+      `Check the registry \u2014 the manifest pins ${missing} for every package, so penv records what the registry states or refuses to record it at all.`
+    );
+  }
+};
+var PackageTooYoungError = class extends import_core.PenvError {
+  name = "PackageTooYoungError";
+  constructor(name, version, publishedAt) {
+    super(
+      "PENV_PACKAGE_TOO_YOUNG",
+      `${name} ${version} was published ${publishedAt}, and penv waits ${MIN_PACKAGE_AGE_DAYS} days before adding a package outside \`${import_core.OFFICIAL_SCOPE}*\``,
+      `Run \`${addCommand(name, version, TRUST_YOUNG_FLAG)}\` to add it anyway and record why. The wait is there because a hijacked publish is usually caught within days.`
+    );
+  }
+};
+var ManifestEntriesUnreadableError = class extends import_core.PenvError {
+  name = "ManifestEntriesUnreadableError";
+  constructor(names) {
+    const one = names.length === 1;
+    super(
+      "PENV_MANIFEST_ENTRIES_UNREADABLE",
+      `${import_core.MANIFEST_PATH} holds ${one ? "an extension entry" : "extension entries"} penv cannot read: ${names.join(", ")}`,
+      one ? `Run \`${addCommand(names[0] ?? "")}\` to rewrite that entry \u2014 it resolves the package again and records what the registry states.` : `Restore it with \`git checkout ${import_core.MANIFEST_PATH}\`. Each \`penv add\` rewrites only its own entry, so more than one broken entry is not something one of them can fix.`
+    );
+  }
+};
+var AddNoDownloadError = class extends import_core.PenvError {
+  name = "AddNoDownloadError";
+  constructor(name) {
+    super(
+      "PENV_ADD_NO_DOWNLOAD",
+      `Adding ${name} means reading the registry for the version and integrity to pin, and \`--no-download\` says this run does not`,
+      `Run \`${addCommand(name)}\` without \`--no-download\`. Nothing was fetched or written.`
+    );
+  }
+};
+var AddNotInteractiveError = class extends import_core.PenvError {
+  name = "AddNotInteractiveError";
+  constructor(name) {
+    super(
+      "PENV_ADD_NOT_INTERACTIVE",
+      `Adding ${name} rewrites ${import_core.MANIFEST_PATH}, and this run has nobody to decide that`,
+      `Run \`${addCommand(name)}\` from a terminal and commit what it writes. In CI, run \`${INSTALL_COMMAND}\` \u2014 it installs the versions the committed manifest already pins.`
+    );
+  }
+};
+var TrustDeclinedError = class extends import_core.PenvError {
+  name = "TrustDeclinedError";
+  constructor(name, version) {
+    super(
+      "PENV_TRUST_DECLINED",
+      `${name} ${version} was not trusted, so penv installed and recorded nothing`,
+      `Run \`${addCommand(name, version)}\` again when you have reviewed what it does.`
+    );
+  }
+};
+var TrustPublisherMissingError = class extends import_core.PenvError {
+  name = "TrustPublisherMissingError";
+  constructor(name, version) {
+    super(
+      "PENV_TRUST_PUBLISHER_MISSING",
+      `The publisher of ${name} ${version} was left empty, and the registry names none either`,
+      `Run \`${addCommand(name, version)}\` again and name the npm account you checked \u2014 a third-party trust block records who was trusted, not only that someone was.`
+    );
+  }
+};
+var TrustReasonMissingError = class extends import_core.PenvError {
+  name = "TrustReasonMissingError";
+  constructor(name, version) {
+    super(
+      "PENV_TRUST_REASON_MISSING",
+      `The reason for trusting ${name} ${version} was left empty`,
+      `Run \`${addCommand(name, version)}\` again and write one line on what you checked \u2014 the next reviewer reads that line, not the diff.`
+    );
+  }
+};
+var DeclarationMissingError = class extends import_core.PenvError {
+  name = "DeclarationMissingError";
+  constructor(name, file) {
+    super(
+      "PENV_DECLARATION_MISSING",
+      `${name} declares its types at \`${file}\`, and the published package has no such file`,
+      `Report it to ${name}. penv commits the declaration a provider ships, so it will not invent one that claims to describe this provider's configuration.`
+    );
+  }
+};
+var DeclarationNotSelfContainedError = class extends import_core.PenvError {
+  name = "DeclarationNotSelfContainedError";
+  constructor(name, file, specifier) {
+    super(
+      "PENV_DECLARATION_NOT_SELF_CONTAINED",
+      `The declaration ${name} ships at \`${file}\` imports \`${specifier}\``,
+      `Report it to ${name}. What penv commits to ${import_core.EXTENSIONS_PATH} is types and nothing else, so it can only carry a declaration that stands on its own.`
+    );
+  }
+};
+var EnginePinUnreleasedError = class extends import_core.PenvError {
+  name = "EnginePinUnreleasedError";
+  constructor() {
+    super(
+      "PENV_ENGINE_PIN_UNRELEASED",
+      `This penv was built from source, so it carries no published integrity for ${import_core.ENGINE_PACKAGE} to write into ${import_core.MANIFEST_PATH}`,
+      "Install penv from npm with `npm install -g @penvhq/launcher` and run the command again \u2014 a released launcher ships the integrity of the engine it ships."
+    );
+  }
+};
+var EnginePinMismatchError = class extends import_core.PenvError {
+  name = "EnginePinMismatchError";
+  constructor(pinned, ran) {
+    super(
+      "PENV_ENGINE_PIN_MISMATCH",
+      `This penv carries the integrity of ${import_core.ENGINE_PACKAGE} ${pinned} and just ran ${ran}, so it cannot record which bytes scaffolded this project`,
+      "Reinstall the launcher with `npm install -g @penvhq/launcher` \u2014 its pin and its engine ship together."
+    );
+  }
+};
+var EngineEntryError = class extends import_core.PenvError {
+  name = "EngineEntryError";
+  constructor(name, version, dir) {
+    super(
+      "PENV_ENGINE_ENTRY",
+      `${name} ${version} in ${dir} declares no bin penv can run`,
+      `Delete ${dir} and run \`${INSTALL_COMMAND}\` to install it again.`
+    );
+  }
+};
+
+// src/declaration.ts
+var AUGMENTATION_TARGET = "@penvhq/core";
+var MODULE_SPECIFIER = /(?:\bfrom|\bmodule|\bimport|\brequire)\s*\(?\s*(["'])([^"']*)\1/g;
+function field(source, key) {
+  return typeof source === "object" && source !== null && Object.hasOwn(source, key) ? source[key] : void 0;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function readExtensionPackage(dir) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "package.json"), "utf8"));
+  } catch {
+    return { types: void 0, onboard: void 0 };
+  }
+  const penv = field(parsed, "penv");
+  return { types: text(field(penv, "types")), onboard: text(field(penv, "onboard")) };
+}
+function header(subject) {
+  const provenance = subject.attested ? "npm records a provenance attestation for it" : "npm records no provenance attestation for it";
+  return `// Written by \`penv add ${subject.name}\`, and committed.
+// ${subject.name} ${subject.version} \u2014 ${provenance}.
+//
+// Types only: this declares the shape of the provider's \`penv.config.ts\`
+// entry. It holds no adapter code, no credentials, and no values.
+`;
+}
+function openShape(name) {
+  return `import type { ProviderConfig } from "${AUGMENTATION_TARGET}";
+
+declare module "${AUGMENTATION_TARGET}" {
+  interface ProviderConfigMap {
+    ${JSON.stringify(name)}: ProviderConfig & { readonly type: ${JSON.stringify(name)} };
+  }
+}
+`;
+}
+function assertSelfContained(name, file, source) {
+  MODULE_SPECIFIER.lastIndex = 0;
+  for (; ; ) {
+    const match = MODULE_SPECIFIER.exec(source);
+    if (match === null) {
+      return;
+    }
+    const specifier = match[2] ?? "";
+    if (specifier !== AUGMENTATION_TARGET) {
+      throw new DeclarationNotSelfContainedError(name, file, specifier);
+    }
+  }
+}
+function renderDeclaration(subject, shipped) {
+  if (shipped === void 0) {
+    return `${header(subject)}
+${openShape(subject.name)}`;
+  }
+  assertSelfContained(subject.name, shipped.file, shipped.source);
+  const body = shipped.source.replace(/^/, "").trimEnd();
+  return `${header(subject)}
+${body}
+`;
+}
+function readShipped(name, dir, declared) {
+  const root = (0, import_node_path.resolve)(dir);
+  const file = (0, import_node_path.resolve)(root, ...declared.split("/"));
+  if (!file.startsWith(root + import_node_path.sep)) {
+    throw new DeclarationMissingError(name, declared);
+  }
+  try {
+    return (0, import_node_fs.readFileSync)(file, "utf8");
+  } catch {
+    throw new DeclarationMissingError(name, declared);
+  }
+}
+function declarationPath(name) {
+  return `${import_core2.EXTENSIONS_PATH}/${name}.d.ts`;
+}
+function writeDeclaration(options) {
+  const relative2 = declarationPath(options.name);
+  const file = (0, import_node_path.join)(options.root, ...relative2.split("/"));
+  let shipped;
+  if (options.types !== void 0) {
+    shipped = {
+      file: options.types,
+      source: readShipped(options.name, options.dir, options.types)
+    };
+  }
+  const text4 = renderDeclaration(options, shipped);
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(file), { recursive: true });
+  (0, import_node_fs.writeFileSync)(file, text4);
+  return relative2;
+}
+
+// src/store.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+
+// src/home.ts
+var import_node_fs2 = require("fs");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var import_core3 = require("@penvhq/core");
+var PENV_HOME_VAR = "PENV_HOME";
+var HOME_META_FILE = "meta.json";
+var INTEGRITY_FILE = ".penv-integrity";
+var NPM_UPDATE_COMMAND = "npm install -g @penvhq/launcher";
+function penvHome(env) {
+  const declared = env[PENV_HOME_VAR];
+  if (declared !== void 0 && declared.trim() !== "") {
+    return (0, import_node_path2.resolve)(declared);
+  }
+  return (0, import_node_path2.join)((0, import_node_os.homedir)(), ".penv");
+}
+function packageDir(home, kind, name, version) {
+  const bucket = (0, import_node_path2.resolve)(home, kind);
+  const dir = (0, import_node_path2.resolve)(bucket, ...name.split("/"), version);
+  if (!dir.startsWith(bucket + import_node_path2.sep)) {
+    throw new import_core3.PenvError(
+      "PENV_HOME_ESCAPE",
+      `\`${name}\` at \`${version}\` resolves to ${dir}, which is outside ${bucket}`,
+      "Name the package exactly as npm does, e.g. `@penvhq/provider-vault`."
+    );
+  }
+  return dir;
+}
+function launcherUpdateCommand(home) {
+  let meta;
+  try {
+    meta = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(home, HOME_META_FILE), "utf8"));
+  } catch {
+    return NPM_UPDATE_COMMAND;
+  }
+  const command = meta?.updateCommand;
+  if (typeof command === "string" && command.trim() !== "") {
+    return command.trim();
+  }
+  return NPM_UPDATE_COMMAND;
+}
+
+// src/integrity.ts
+var import_node_crypto = require("crypto");
+function integrityOf(bytes) {
+  return `sha512-${(0, import_node_crypto.createHash)("sha512").update(bytes).digest("base64")}`;
+}
+
+// src/tar.ts
+var import_node_zlib = require("zlib");
+var BLOCK = 512;
+var NAME = { start: 0, length: 100 };
+var SIZE = { start: 124, length: 12 };
+var TYPE_FLAG = 156;
+var PREFIX = { start: 345, length: 155 };
+var ROOT = "package/";
+function text2(block, start, length) {
+  const field2 = block.subarray(start, start + length);
+  const end = field2.indexOf(0);
+  return new TextDecoder().decode(end === -1 ? field2 : field2.subarray(0, end)).trim();
+}
+function octal(block, start, length) {
+  const value = text2(block, start, length);
+  return value === "" ? 0 : Number.parseInt(value, 8);
+}
+function paxPath(data) {
+  for (const record2 of new TextDecoder().decode(data).split("\n")) {
+    const match = /^\d+ path=(.*)$/.exec(record2);
+    if (match?.[1] !== void 0) {
+      return match[1];
+    }
+  }
+  return void 0;
+}
+function safePath(raw, subject) {
+  if (!raw.startsWith(ROOT)) {
+    throw new ArchiveError(subject.name, subject.version, raw);
+  }
+  const path = raw.slice(ROOT.length);
+  const segments = path.split("/");
+  if (path === "" || path.includes("\\") || path.startsWith("/") || /^[A-Za-z]:/.test(path) || segments.some((segment) => segment === ".." || segment === "")) {
+    throw new ArchiveError(subject.name, subject.version, raw);
+  }
+  return path;
+}
+function readTarball(gzipped, subject) {
+  const archive = new Uint8Array((0, import_node_zlib.gunzipSync)(gzipped));
+  const entries = [];
+  let override;
+  for (let offset = 0; offset + BLOCK <= archive.length; offset += BLOCK) {
+    const header2 = archive.subarray(offset, offset + BLOCK);
+    const name = text2(header2, NAME.start, NAME.length);
+    if (name === "") {
+      break;
+    }
+    const size = octal(header2, SIZE.start, SIZE.length);
+    const dataStart = offset + BLOCK;
+    if (!Number.isSafeInteger(size) || size < 0 || dataStart + size > archive.length) {
+      throw new ArchiveError(subject.name, subject.version, name);
+    }
+    const flag = String.fromCharCode(header2[TYPE_FLAG] ?? 0);
+    const data = archive.subarray(dataStart, dataStart + size);
+    offset += Math.ceil(size / BLOCK) * BLOCK;
+    if (flag === "x" || flag === "g") {
+      override = paxPath(data) ?? override;
+      continue;
+    }
+    const prefix = text2(header2, PREFIX.start, PREFIX.length);
+    const raw = override ?? (prefix === "" ? name : `${prefix}/${name}`);
+    override = void 0;
+    if (flag === "5") {
+      continue;
+    }
+    if (flag !== "0" && flag !== "\0") {
+      throw new ArchiveError(subject.name, subject.version, raw);
+    }
+    entries.push({ path: safePath(raw, subject), bytes: new Uint8Array(data) });
+  }
+  return entries;
+}
+
+// src/store.ts
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+function tarballUrl(pin) {
+  const registry = (pin.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
+  const basename = pin.name.slice(pin.name.lastIndexOf("/") + 1);
+  return `${registry}/${pin.name}/-/${basename}-${pin.version}.tgz`;
+}
+function inspectInstall(home, kind, pin) {
+  const dir = packageDir(home, kind, pin.name, pin.version);
+  if (!(0, import_node_fs3.existsSync)(dir)) {
+    return { dir, state: "absent" };
+  }
+  let recorded;
+  try {
+    recorded = (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(dir, INTEGRITY_FILE), "utf8").trim();
+  } catch {
+    return { dir, state: "corrupt" };
+  }
+  return { dir, state: recorded === pin.integrity ? "installed" : "corrupt" };
+}
+async function installPin(options) {
+  const { home, kind, pin, fetcher } = options;
+  const dir = packageDir(home, kind, pin.name, pin.version);
+  const url = tarballUrl(pin);
+  let bytes;
+  try {
+    bytes = await fetcher.get(url);
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new DownloadFailedError(pin.name, pin.version, url, detail);
+  }
+  if (integrityOf(bytes) !== pin.integrity) {
+    throw new DownloadIntegrityError(pin.name, pin.version, url);
+  }
+  const entries = readTarball(bytes, pin);
+  const parent = (0, import_node_path3.dirname)(dir);
+  (0, import_node_fs3.mkdirSync)(parent, { recursive: true });
+  const staging = (0, import_node_fs3.mkdtempSync)((0, import_node_path3.join)(parent, `.${pin.version}-`));
+  try {
+    for (const entry of entries) {
+      const file = (0, import_node_path3.join)(staging, ...entry.path.split("/"));
+      (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(file), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(file, entry.bytes);
+    }
+    (0, import_node_fs3.writeFileSync)((0, import_node_path3.join)(staging, INTEGRITY_FILE), `${pin.integrity}
+`);
+    (0, import_node_fs3.rmSync)(dir, { recursive: true, force: true });
+    (0, import_node_fs3.renameSync)(staging, dir);
+  } finally {
+    (0, import_node_fs3.rmSync)(staging, { recursive: true, force: true });
+  }
+  return dir;
+}
+
+// src/registry.ts
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function at(source, key) {
+  return source !== void 0 && Object.hasOwn(source, key) ? source[key] : void 0;
+}
+function text3(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function packumentUrl(registry, name) {
+  return `${(registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "")}/${name}`;
+}
+function publisherOf(release) {
+  const npmUser = text3(at(record(release._npmUser), "name"));
+  if (npmUser !== void 0) {
+    return npmUser;
+  }
+  const maintainers = release.maintainers;
+  if (!Array.isArray(maintainers)) {
+    return void 0;
+  }
+  return text3(at(record(maintainers[0]), "name"));
+}
+async function fetchRelease(query) {
+  const url = packumentUrl(query.registry, query.name);
+  let bytes;
+  try {
+    bytes = await query.fetcher.get(url);
+  } catch (cause) {
+    throw new RegistryUnreadableError(
+      query.name,
+      url,
+      cause instanceof Error ? cause.message : String(cause)
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(bytes));
+  } catch (cause) {
+    throw new RegistryUnreadableError(
+      query.name,
+      url,
+      cause instanceof Error ? cause.message : String(cause)
+    );
+  }
+  const packument = record(parsed);
+  const versions = record(at(packument, "versions"));
+  if (versions === void 0) {
+    throw new PackageUnknownError(query.name, url);
+  }
+  const tags = record(at(packument, "dist-tags"));
+  const asked = query.version ?? text3(at(tags, "latest"));
+  if (asked === void 0) {
+    throw new PackageUnknownError(query.name, url);
+  }
+  const version = record(at(versions, asked)) === void 0 ? text3(at(tags, asked)) ?? asked : asked;
+  const release = record(at(versions, version));
+  if (release === void 0) {
+    throw new VersionUnknownError(query.name, asked, url);
+  }
+  const dist = record(at(release, "dist"));
+  const integrity = text3(at(dist, "integrity"));
+  const publishedAt = text3(at(record(at(packument, "time")), version));
+  if (integrity === void 0) {
+    throw new ReleaseIncompleteError(query.name, version, url, "integrity");
+  }
+  if (publishedAt === void 0 || Number.isNaN(Date.parse(publishedAt))) {
+    throw new ReleaseIncompleteError(query.name, version, url, "publish time");
+  }
+  return {
+    name: query.name,
+    version,
+    integrity,
+    publishedAt,
+    publisher: publisherOf(release),
+    attested: record(at(dist, "attestations")) !== void 0
+  };
+}
+
+// src/repair.ts
+var import_core4 = require("@penvhq/core");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseWith(base, extensions) {
+  return (0, import_core4.parseManifest)(JSON.stringify({ ...base, extensions }));
+}
+function readManifestForRepair(text4) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text4);
+  } catch {
+    return { manifest: (0, import_core4.parseManifest)(text4), broken: [] };
+  }
+  const root = isPlainObject(parsed) ? parsed : void 0;
+  const declared = root?.extensions;
+  if (root === void 0 || !isPlainObject(declared)) {
+    return { manifest: (0, import_core4.parseManifest)(text4), broken: [] };
+  }
+  const { extensions: _, ...base } = root;
+  parseWith(base, {});
+  const kept = {};
+  const broken = [];
+  for (const [name, entry] of Object.entries(declared)) {
+    try {
+      parseWith(base, { [name]: entry });
+      kept[name] = entry;
+    } catch {
+      broken.push(name);
+    }
+  }
+  return { manifest: parseWith(base, kept), broken: broken.sort() };
+}
+
+// src/add.ts
+var PACKAGE_NAME = /^(?:@[a-z0-9~-][a-z0-9._~-]*\/)?[a-z0-9~-][a-z0-9._~-]*$/;
+var REGISTRY_FLAG = "--registry";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function normalizeRegistry(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new AddRegistryError(raw);
+  }
+  if (url.protocol !== "https:") {
+    throw new AddRegistryError(raw);
+  }
+  return url.origin === new URL(DEFAULT_REGISTRY).origin ? void 0 : raw.replace(/\/+$/, "");
+}
+function splitSpec(spec) {
+  const at2 = spec.lastIndexOf("@");
+  if (at2 <= 0) {
+    return { name: spec, version: void 0 };
+  }
+  return { name: spec.slice(0, at2), version: spec.slice(at2 + 1) };
+}
+function parseRequest(argv) {
+  let spec;
+  let registry;
+  let trustYoung = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token === TRUST_YOUNG_FLAG) {
+      trustYoung = true;
+      continue;
+    }
+    if (token === REGISTRY_FLAG) {
+      const value = argv[index + 1];
+      if (value === void 0 || value.startsWith("-")) {
+        throw new AddFlagError(REGISTRY_FLAG);
+      }
+      registry = normalizeRegistry(value);
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      throw new AddFlagError(token);
+    }
+    if (spec !== void 0) {
+      throw new AddSubjectError();
+    }
+    spec = token;
+  }
+  if (spec === void 0 || spec === "") {
+    throw new AddSubjectError();
+  }
+  const { name, version } = splitSpec(spec);
+  if (!PACKAGE_NAME.test(name) || version === "") {
+    throw new AddPackageNameError(spec);
+  }
+  return { name, version, registry, trustYoung };
+}
+function tierOf(request) {
+  if (request.name.startsWith(import_core5.OFFICIAL_SCOPE)) {
+    if (request.registry !== void 0) {
+      throw new OfficialRegistryError(request.name, request.registry);
+    }
+    return "official";
+  }
+  return request.registry === void 0 ? "third-party" : "private";
+}
+function showRelease(io, release, registry) {
+  io.out(`  publisher   ${release.publisher ?? "not stated by the registry"}`);
+  io.out(`  published   ${release.publishedAt}`);
+  io.out(`  integrity   ${release.integrity}`);
+  if (registry !== void 0) {
+    io.out(`  registry    ${registry}`);
+  }
+}
+async function askReason(io, release) {
+  const reason = (await io.ask("Why do you trust it? One line, for the next reviewer.")).trim();
+  if (reason === "") {
+    throw new TrustReasonMissingError(release.name, release.version);
+  }
+  return reason;
+}
+async function trustFor(tier, release, request, io, now) {
+  if (tier === "official") {
+    return void 0;
+  }
+  if (tier === "third-party") {
+    const age = now.getTime() - Date.parse(release.publishedAt);
+    if (age < MIN_PACKAGE_AGE_DAYS * DAY_MS && !request.trustYoung) {
+      throw new PackageTooYoungError(release.name, release.version, release.publishedAt);
+    }
+    io.out(
+      `${release.name} ${release.version} is outside \`${import_core5.OFFICIAL_SCOPE}*\`, so the manifest records who you trusted and why.`
+    );
+    showRelease(io, release, void 0);
+    if (!await io.confirm(`Trust ${release.name} ${release.version}?`)) {
+      throw new TrustDeclinedError(release.name, release.version);
+    }
+    const publisher = release.publisher ?? (await io.ask("Who publishes it? The npm account name.")).trim();
+    if (publisher === "") {
+      throw new TrustPublisherMissingError(release.name, release.version);
+    }
+    return {
+      tier: "third-party",
+      publisher,
+      publishedAt: release.publishedAt,
+      acknowledgedAt: now.toISOString(),
+      reason: await askReason(io, release)
+    };
+  }
+  io.out(
+    `${release.name} ${release.version} comes from a private registry. The manifest records the registry and your acknowledgement; your \`.npmrc\` keeps the credentials.`
+  );
+  showRelease(io, release, request.registry);
+  if (!await io.confirm(`Trust ${release.name} ${release.version}?`)) {
+    throw new TrustDeclinedError(release.name, release.version);
+  }
+  return {
+    tier: "private",
+    acknowledgedAt: now.toISOString(),
+    reason: await askReason(io, release)
+  };
+}
+function recordExtension(manifestFile, name, entry) {
+  const { manifest, broken } = readManifestForRepair((0, import_node_fs4.readFileSync)(manifestFile, "utf8"));
+  const others = broken.filter((other) => other !== name);
+  if (others.length > 0) {
+    throw new ManifestEntriesUnreadableError(others);
+  }
+  const next = {
+    ...manifest,
+    extensions: { ...manifest.extensions, [name]: entry }
+  };
+  return (0, import_core5.serializeManifest)(next);
+}
+async function offerConfigEdit(options, name) {
+  const { io, root } = options;
+  const configFile = (0, import_core5.findConfigFile)(root);
+  const line = `Add \`type: ${JSON.stringify(name)}\` to an environment in penv.config.ts.`;
+  if (configFile === void 0) {
+    io.out(line);
+    return;
+  }
+  const shown = (0, import_node_path4.relative)(root, configFile).split(import_node_path4.sep).join("/");
+  let current = (0, import_node_fs4.readFileSync)(configFile, "utf8");
+  const entries = readProviderEntries(current);
+  if (entries === void 0 || entries.length === 0) {
+    io.out(line);
+    return;
+  }
+  if (entries.every((entry) => entry.type === name)) {
+    return;
+  }
+  if (!io.interactive) {
+    io.out(line);
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.type === name) {
+      continue;
+    }
+    if (!await io.confirm(`Point \`${entry.environment}\` at ${name} in ${shown}?`)) {
+      continue;
+    }
+    const next = setProviderType(current, entry.environment, name);
+    if (next === void 0) {
+      io.out(`Add \`type: ${JSON.stringify(name)}\` to \`${entry.environment}\` in ${shown}.`);
+      continue;
+    }
+    current = next;
+    (0, import_node_fs4.writeFileSync)(configFile, current);
+    io.out(`\u2713 ${shown} points \`${entry.environment}\` at ${name}`);
+  }
+}
+async function offerOnboarding(io, name, onboard) {
+  if (onboard === void 0) {
+    return void 0;
+  }
+  const args = onboard.split(/\s+/).filter((token) => token !== "");
+  if (args.length === 0) {
+    return void 0;
+  }
+  const command = `penv ${args.join(" ")}`;
+  if (io.interactive && await io.confirm(`Run \`${command}\` now?`)) {
+    return args;
+  }
+  io.out(`Run \`${command}\` to finish setting ${name} up.`);
+  return void 0;
+}
+async function add(options) {
+  const { io, fetcher, home, root, manifestFile } = options;
+  const request = parseRequest(options.argv);
+  const tier = tierOf(request);
+  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (options.noDownload === true) {
+    throw new AddNoDownloadError(request.name);
+  }
+  if (options.ci === true || !io.interactive) {
+    throw new AddNotInteractiveError(request.name);
+  }
+  const release = await fetchRelease({
+    name: request.name,
+    ...request.version === void 0 ? {} : { version: request.version },
+    ...request.registry === void 0 ? {} : { registry: request.registry },
+    fetcher
+  });
+  const trust = await trustFor(tier, release, request, io, now);
+  const entry = {
+    version: release.version,
+    integrity: release.integrity,
+    ...request.registry === void 0 ? {} : { registry: request.registry },
+    ...trust === void 0 ? {} : { trust }
+  };
+  const manifestText = recordExtension(manifestFile, release.name, entry);
+  const dir = await installPin({
+    home,
+    kind: "extensions",
+    pin: {
+      name: release.name,
+      version: release.version,
+      integrity: release.integrity,
+      ...request.registry === void 0 ? {} : { registry: request.registry }
+    },
+    fetcher
+  });
+  const installed = readExtensionPackage(dir);
+  const declaration = writeDeclaration({
+    root,
+    dir,
+    name: release.name,
+    version: release.version,
+    attested: release.attested,
+    types: installed.types
+  });
+  (0, import_node_fs4.writeFileSync)(manifestFile, manifestText);
+  const provenance = release.attested ? "npm records a provenance attestation" : "npm records no provenance attestation";
+  io.out(`\u2713 ${release.name} ${release.version} installed \u2014 ${provenance}`);
+  io.out(`\u2713 ${import_core5.MANIFEST_PATH} pins it`);
+  io.out(`\u2713 ${declaration} declares its config type`);
+  await offerConfigEdit(options, release.name);
+  return { onboard: await offerOnboarding(io, release.name, installed.onboard) };
+}
+
+// src/delegate.ts
+var import_node_child_process = require("child_process");
+var import_node_os2 = require("os");
+var FORWARDED = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+function signalNumber(signal) {
+  const signals = import_node_os2.constants.signals;
+  return signals[signal] ?? 0;
+}
+function nodeSpawner() {
+  return (delegation) => new Promise((settle, fail) => {
+    const child = (0, import_node_child_process.spawn)(delegation.command, [...delegation.args], {
+      cwd: delegation.cwd,
+      env: { ...delegation.env },
+      stdio: "inherit"
+    });
+    const handlers = FORWARDED.map((signal) => {
+      const handler = () => {
+        child.kill(signal);
+      };
+      process.on(signal, handler);
+      return { signal, handler };
+    });
+    const release = () => {
+      for (const { signal, handler } of handlers) {
+        process.off(signal, handler);
+      }
+    };
+    child.on("error", (error) => {
+      release();
+      fail(error);
+    });
+    child.on("exit", (code, signal) => {
+      release();
+      if (signal !== null) {
+        process.kill(process.pid, signal);
+        settle(128 + signalNumber(signal));
+        return;
+      }
+      settle(code ?? 0);
+    });
+  });
+}
+
+// src/engine.ts
+var import_node_fs5 = require("fs");
+var import_node_module = require("module");
+var import_node_path5 = require("path");
+var import_core6 = require("@penvhq/core");
+var import_meta = {};
+var ENGINE_BIN = "penv-engine";
+function readPackageManifest(dir) {
+  try {
+    return JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path5.join)(dir, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function binPath(bin) {
+  if (typeof bin === "string") {
+    return bin;
+  }
+  if (typeof bin !== "object" || bin === null) {
+    return void 0;
+  }
+  const entries = Object.entries(bin).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  const named = entries.find(([name]) => name === ENGINE_BIN);
+  const chosen = named ?? (entries.length === 1 ? entries[0] : void 0);
+  return chosen?.[1];
+}
+function engineAt(dir, name, version) {
+  const manifest = readPackageManifest(dir);
+  const bin = manifest === void 0 ? void 0 : binPath(manifest.bin);
+  const root = (0, import_node_path5.resolve)(dir);
+  const entry = bin === void 0 ? void 0 : (0, import_node_path5.resolve)(root, bin);
+  if (entry === void 0 || !entry.startsWith(root + import_node_path5.sep) || !(0, import_node_fs5.existsSync)(entry)) {
+    throw new EngineEntryError(name, version, dir);
+  }
+  return { name, version, dir, entry };
+}
+function bundledEngine() {
+  const require2 = (0, import_node_module.createRequire)(import_meta.url);
+  let manifestFile;
+  try {
+    manifestFile = require2.resolve(`${import_core6.ENGINE_PACKAGE}/package.json`);
+  } catch {
+    throw new import_core6.PenvError(
+      "PENV_NO_BUNDLED_ENGINE",
+      `This penv installation is missing ${import_core6.ENGINE_PACKAGE}, the engine it runs \`init\` with`,
+      "Reinstall the launcher with `npm install -g @penvhq/launcher`."
+    );
+  }
+  const dir = (0, import_node_path5.dirname)(manifestFile);
+  const version = readPackageManifest(dir)?.version;
+  return engineAt(dir, import_core6.ENGINE_PACKAGE, typeof version === "string" ? version : "unknown");
+}
+
+// src/fetcher.ts
+function httpFetcher() {
+  return {
+    async get(url) {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`the registry answered ${response.status} ${response.statusText}`);
+      }
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  };
+}
+
+// src/launcher.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+var import_core9 = require("@penvhq/core");
+
+// src/pins.ts
+var import_core7 = require("@penvhq/core");
+var DEV_PIN_INTEGRITY = "sha512-development-build-not-a-published-release";
+var DEV_PIN_VERSION = "0.0.0-dev";
+var BUNDLED_ENGINE_PIN = {
+  package: import_core7.ENGINE_PACKAGE,
+  version: DEV_PIN_VERSION,
+  integrity: DEV_PIN_INTEGRITY
+};
+function assertReleasePin(pin) {
+  if (pin.integrity === DEV_PIN_INTEGRITY || pin.version === DEV_PIN_VERSION) {
+    throw new EnginePinUnreleasedError();
+  }
+}
+function releaseEnginePin(pin, ranVersion) {
+  assertReleasePin(pin);
+  if (pin.version !== ranVersion) {
+    throw new EnginePinMismatchError(pin.version, ranVersion);
+  }
+  return pin;
+}
+
+// src/project.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var import_core8 = require("@penvhq/core");
+var MANIFEST_SEGMENTS = import_core8.MANIFEST_PATH.split("/");
+function findUp(cwd, matches) {
+  let dir = (0, import_node_path6.resolve)(cwd);
+  for (; ; ) {
+    if (matches(dir)) {
+      return dir;
+    }
+    const parent = (0, import_node_path6.dirname)(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+function findProject(cwd) {
+  const root = findUp(cwd, (dir) => (0, import_node_fs6.existsSync)((0, import_node_path6.join)(dir, ...MANIFEST_SEGMENTS)));
+  return root === void 0 ? void 0 : { root, manifestFile: (0, import_node_path6.join)(root, ...MANIFEST_SEGMENTS) };
+}
+function findAdoptedRoot(cwd) {
+  return findUp(cwd, (dir) => (0, import_node_fs6.existsSync)((0, import_core8.stateDir)(dir)));
+}
+
+// src/launcher.ts
+var INSTALL = "install";
+var ADD = "add";
+var VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-v"]);
+var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+var NO_DOWNLOAD = "--no-download";
+var ADOPTS = /* @__PURE__ */ new Set(["init", "migrate"]);
+function splitLauncherFlags(argv) {
+  let index = 0;
+  let noDownload = false;
+  while (argv[index] === NO_DOWNLOAD) {
+    noDownload = true;
+    index += 1;
+  }
+  return { noDownload, forwarded: argv.slice(index) };
+}
+function invokedCommand(argv) {
+  const parts = argv.map((token) => /\s/.test(token) ? JSON.stringify(token) : token);
+  return ["penv", ...parts].join(" ");
+}
+function isCi(env) {
+  const ci = env.CI;
+  return ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+}
+function enginePinOf(manifest) {
+  return {
+    name: manifest.engine.package,
+    version: manifest.engine.version,
+    integrity: manifest.engine.integrity
+  };
+}
+function extensionPinsOf(manifest) {
+  return Object.entries(manifest.extensions).map(([name, entry]) => ({
+    name,
+    version: entry.version,
+    integrity: entry.integrity,
+    ...entry.registry === void 0 ? {} : { registry: entry.registry }
+  }));
+}
+function pinsOf(manifest) {
+  return [
+    { kind: "engines", pin: enginePinOf(manifest) },
+    ...extensionPinsOf(manifest).map((pin) => ({ kind: "extensions", pin }))
+  ];
+}
+function reportable(error, home, argv) {
+  return error instanceof import_core9.UnsupportedManifestFormatError ? error.withLauncherUpdate({
+    updateCommand: launcherUpdateCommand(home),
+    invokedCommand: invokedCommand(argv)
+  }) : error;
+}
+function readManifest(manifestFile, home, argv) {
+  try {
+    return (0, import_core9.parseManifest)((0, import_node_fs7.readFileSync)(manifestFile, "utf8"));
+  } catch (error) {
+    throw reportable(error, home, argv);
+  }
+}
+function readManifestToRepair(manifestFile, home, argv) {
+  try {
+    return readManifestForRepair((0, import_node_fs7.readFileSync)(manifestFile, "utf8"));
+  } catch (error) {
+    throw reportable(error, home, argv);
+  }
+}
+function report(error, io) {
+  if (error instanceof import_core9.PenvError && error.remedy !== void 0) {
+    const suffix = `
+  ${error.remedy}`;
+    const message = error.message.endsWith(suffix) ? error.message.slice(0, -suffix.length) : error.message;
+    io.err(`\u2717 ${message}`);
+    io.err(`  \u2192 ${error.remedy}`);
+    return;
+  }
+  io.err(`\u2717 ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+}
+async function runLauncher(options) {
+  try {
+    return await launch(options);
+  } catch (error) {
+    report(error, options.io);
+    return 1;
+  }
+}
+async function launch(options) {
+  const { argv, cwd, env, io } = options;
+  const { noDownload, forwarded } = splitLauncherFlags(argv);
+  const first = forwarded[0];
+  const home = penvHome(env);
+  const project = findProject(cwd);
+  if (project === void 0) {
+    if (first !== void 0 && VERSION_FLAGS.has(first)) {
+      io.out(`penv ${options.bundledEngine().version}`);
+      return 0;
+    }
+    if (first === void 0 || HELP_FLAGS.has(first)) {
+      return delegate(options, options.bundledEngine(), forwarded, home, cwd);
+    }
+    if (ADOPTS.has(first)) {
+      return adopt(options, forwarded, home, cwd);
+    }
+    throw new NoProjectError(cwd);
+  }
+  if (first === INSTALL) {
+    const { manifest: manifest2, broken } = readManifestToRepair(project.manifestFile, home, argv);
+    return install(options, pinsOf(manifest2), home, broken);
+  }
+  if (first === ADD) {
+    return addExtension(options, project, home, forwarded.slice(1), noDownload);
+  }
+  const manifest = readManifest(project.manifestFile, home, argv);
+  if (first !== void 0 && VERSION_FLAGS.has(first)) {
+    io.out(`penv ${manifest.engine.version}`);
+    return 0;
+  }
+  const enginePin = enginePinOf(manifest);
+  const engineDir = await ensure(options, "engines", enginePin, home, noDownload);
+  for (const pin of extensionPinsOf(manifest)) {
+    await ensure(options, "extensions", pin, home, noDownload);
+  }
+  const engine = engineAt(engineDir, enginePin.name, enginePin.version);
+  return delegate(options, engine, forwarded, home, cwd);
+}
+async function adopt(options, forwarded, home, cwd) {
+  const engine = options.bundledEngine();
+  const code = await delegate(options, engine, forwarded, home, cwd);
+  if (code !== 0) {
+    return code;
+  }
+  const root = findAdoptedRoot(cwd);
+  if (root === void 0) {
+    return 0;
+  }
+  const manifestFile = (0, import_node_path7.join)(root, ...import_core9.MANIFEST_PATH.split("/"));
+  if ((0, import_node_fs7.existsSync)(manifestFile)) {
+    return 0;
+  }
+  const pin = releaseEnginePin(options.bundledPin, engine.version);
+  (0, import_node_fs7.writeFileSync)(
+    manifestFile,
+    (0, import_core9.serializeManifest)({ format: import_core9.MANIFEST_FORMAT, engine: pin, extensions: {} })
+  );
+  options.io.out(`\u2713 ${import_core9.MANIFEST_PATH} pins ${pin.package} ${pin.version}`);
+  return 0;
+}
+async function ensure(options, kind, pin, home, noDownload) {
+  const { io, env, fetcher } = options;
+  const { dir, state } = inspectInstall(home, kind, pin);
+  if (state === "installed") {
+    return dir;
+  }
+  if (state === "corrupt") {
+    throw new PackageCorruptError(pin.name, pin.version, dir);
+  }
+  if (noDownload || isCi(env) || !io.interactive) {
+    throw new PackageMissingError(pin.name, pin.version, home);
+  }
+  const consented = await io.confirm(
+    `penv needs ${pin.name} ${pin.version} for this project. Download and verify it now?`
+  );
+  if (!consented) {
+    throw new InstallDeclinedError(pin.name, pin.version);
+  }
+  return installPin({ home, kind, pin, fetcher });
+}
+async function install(options, pins, home, broken) {
+  for (const { kind, pin } of pins) {
+    const { dir, state } = inspectInstall(home, kind, pin);
+    if (state === "corrupt") {
+      throw new PackageCorruptError(pin.name, pin.version, dir);
+    }
+    if (state === "installed") {
+      options.io.out(`\u2713 ${pin.name} ${pin.version} already installed`);
+      continue;
+    }
+    await installPin({ home, kind, pin, fetcher: options.fetcher });
+    options.io.out(`\u2713 ${pin.name} ${pin.version} installed`);
+  }
+  if (broken.length > 0) {
+    report(new ManifestEntriesUnreadableError(broken), options.io);
+    return 1;
+  }
+  return 0;
+}
+async function addExtension(options, project, home, argv, noDownload) {
+  const { onboard } = await add({
+    argv,
+    root: project.root,
+    manifestFile: project.manifestFile,
+    home,
+    io: options.io,
+    fetcher: options.fetcher,
+    noDownload,
+    ci: isCi(options.env)
+  });
+  if (onboard === void 0) {
+    return 0;
+  }
+  const enginePin = enginePinOf(readManifest(project.manifestFile, home, options.argv));
+  const dir = await ensure(options, "engines", enginePin, home, noDownload);
+  const engine = engineAt(dir, enginePin.name, enginePin.version);
+  return delegate(options, engine, onboard, home, options.cwd);
+}
+function delegate(options, engine, forwarded, home, cwd) {
+  return options.spawn({
+    command: process.execPath,
+    args: [engine.entry, ...forwarded],
+    cwd,
+    env: { ...options.env, [PENV_HOME_VAR]: home }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddFlagError,
+  AddNoDownloadError,
+  AddNotInteractiveError,
+  AddPackageNameError,
+  AddRegistryError,
+  AddSubjectError,
+  ArchiveError,
+  BUNDLED_ENGINE_PIN,
+  DEFAULT_REGISTRY,
+  DEV_PIN_INTEGRITY,
+  DEV_PIN_VERSION,
+  DeclarationMissingError,
+  DeclarationNotSelfContainedError,
+  DownloadFailedError,
+  DownloadIntegrityError,
+  ENGINE_BIN,
+  EngineEntryError,
+  EnginePinMismatchError,
+  EnginePinUnreleasedError,
+  HOME_META_FILE,
+  INSTALL_COMMAND,
+  INTEGRITY_FILE,
+  InstallDeclinedError,
+  MIN_PACKAGE_AGE_DAYS,
+  NPM_UPDATE_COMMAND,
+  NoProjectError,
+  OfficialRegistryError,
+  PENV_HOME_VAR,
+  PackageCorruptError,
+  PackageMissingError,
+  PackageTooYoungError,
+  PackageUnknownError,
+  RegistryUnreadableError,
+  ReleaseIncompleteError,
+  TRUST_YOUNG_FLAG,
+  TrustDeclinedError,
+  TrustPublisherMissingError,
+  TrustReasonMissingError,
+  VersionUnknownError,
+  add,
+  assertReleasePin,
+  bundledEngine,
+  declarationPath,
+  engineAt,
+  fetchRelease,
+  findAdoptedRoot,
+  findProject,
+  httpFetcher,
+  inspectInstall,
+  installPin,
+  integrityOf,
+  launcherUpdateCommand,
+  nodeSpawner,
+  packageDir,
+  packumentUrl,
+  penvHome,
+  readExtensionPackage,
+  readProviderEntries,
+  readTarball,
+  releaseEnginePin,
+  renderDeclaration,
+  runLauncher,
+  setProviderType,
+  tarballUrl,
+  writeDeclaration
+});
+//# sourceMappingURL=index.cjs.map