@penvhq/launcher 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,601 @@
+import { PenvError, ManifestEngine } from '@penvhq/core';
+
+/**
+ * Every byte penv downloads comes through here.
+ *
+ * One method, so the test suite hands the store a fake and the whole launcher
+ * runs with no network at all — and so the "CI never downloads" guarantee is a
+ * property of one call site rather than of every place a URL is built.
+ */
+interface Fetcher {
+    /** The bytes at `url`, or a thrown error saying what the registry did. */
+    get(url: string): Promise<Uint8Array>;
+}
+/** The real one: `fetch`, and a thrown error for anything that is not 200. */
+declare function httpFetcher(): Fetcher;
+
+/**
+ * The terminal, as three questions and two streams.
+ *
+ * It lives apart from the protocol because `penv add` asks the only question
+ * penv cannot answer for anyone: why a stranger's code is trusted. `confirm` is
+ * a decision penv could describe; `ask` is a sentence only a person can write.
+ */
+interface LauncherIo {
+    out(line: string): void;
+    err(line: string): void;
+    /** Whether a human is at the other end of the streams. */
+    readonly interactive: boolean;
+    confirm(question: string): Promise<boolean>;
+    /** A free-text answer, trimmed. Empty means the person declined to write one. */
+    ask(question: string): Promise<string>;
+}
+
+/**
+ * `penv add <package>` — the one command that decides to trust something.
+ *
+ * It belongs to the launcher rather than the engine because everything it does
+ * is the launcher's: resolve an exact version, verify the bytes, install them
+ * into `$PENV_HOME`, and write the manifest that pins them. No engine is needed
+ * for any of that, and the engine importing the store would close a cycle.
+ *
+ * The trust model exists for strangers, and only strangers pay it. An
+ * `@penvhq/*` package is resolved, verified and recorded without one question;
+ * a public third-party package waits out a minimum age and commits a block
+ * saying who published it and why a person trusted it; a package from a private
+ * registry commits the registry and the acknowledgement. Credentials are never
+ * part of any of it — `.npmrc` owns those.
+ *
+ * Nothing here puts adapter code on any startup path. What lands in the project
+ * is two committed files with no runtime in them: the manifest entry, and a
+ * type-only declaration.
+ *
+ * Because those two files are committed, `add` is a decision and needs a person:
+ * `--no-download` and a run with nobody at it are both refused before the first
+ * request, and CI gets `penv install`, which installs what the manifest already
+ * pins rather than choosing what it should.
+ */
+
+interface AddOptions {
+    /** The tokens after `add`. */
+    readonly argv: readonly string[];
+    /** The project root — the directory holding `.penv/`. */
+    readonly root: string;
+    readonly manifestFile: string;
+    readonly home: string;
+    readonly io: LauncherIo;
+    readonly fetcher: Fetcher;
+    /** The launcher's `--no-download`: this run reaches no registry at all. */
+    readonly noDownload?: boolean;
+    /** True on a CI runner, which may have a terminal and still have nobody at it. */
+    readonly ci?: boolean;
+    /** Injected so the age gate is testable without waiting seven days. */
+    readonly now?: () => Date;
+}
+interface AddResult {
+    /** The engine command the provider declares, when its offer was accepted. */
+    readonly onboard: readonly string[] | undefined;
+}
+declare function add(options: AddOptions): Promise<AddResult>;
+
+/**
+ * The one-line edit `add` offers to `penv.config.ts`.
+ *
+ * The file is the user's, so it is scanned rather than parsed and re-emitted:
+ * reformatting someone's config — dropping its comments, resorting its keys — to
+ * change one string is not the edit that was offered. The scanner understands
+ * exactly one thing, the `providers` block, and answers "I do not know this
+ * file" for anything else rather than guessing at a rewrite.
+ */
+/** One environment's entry in the `providers` block. */
+interface ProviderEntry {
+    readonly environment: string;
+    /** The package it names today, when the entry declares a `type` string. */
+    readonly type: string | undefined;
+}
+/** Every environment the `providers` block names, in the order the file declares them. */
+declare function readProviderEntries(source: string): ProviderEntry[] | undefined;
+/** The same text with one environment pointed at `type`, or `undefined` if it cannot be. */
+declare function setProviderType(source: string, environment: string, type: string): string | undefined;
+
+/**
+ * The committed, type-only declaration an added extension contributes.
+ *
+ * The adapter lives in `$PENV_HOME` and is loaded only for an explicit provider
+ * operation, so the project can never import it — which would leave
+ * `penv.config.ts` untyped for exactly the providers it names. This closes that
+ * gap the only way a committed file can: by carrying the provider's own config
+ * declaration as text, checked to reach for nothing the project does not have.
+ *
+ * A package points at that declaration with `penv.types` in its `package.json`;
+ * one that ships none gets the open base shape under its own name, which is
+ * still enough for the `type` field to be checked against something real.
+ */
+/** What an extension's `package.json` tells `add`, and nothing more. */
+interface ExtensionPackage {
+    /** A path inside the package to a self-contained declaration file. */
+    readonly types: string | undefined;
+    /** The engine command that finishes setting this provider up, e.g. `cloud login`. */
+    readonly onboard: string | undefined;
+}
+/**
+ * The `penv` block of an installed package. Advisory, so a package without one —
+ * or with an unreadable `package.json` — declares nothing rather than failing an
+ * install that already succeeded.
+ */
+declare function readExtensionPackage(dir: string): ExtensionPackage;
+interface DeclarationSubject {
+    readonly name: string;
+    readonly version: string;
+    /** Recorded in the header: what npm knew about where these bytes came from. */
+    readonly attested: boolean;
+}
+/** The declaration's text: the package's own, or the open shape under its name. */
+declare function renderDeclaration(subject: DeclarationSubject, shipped?: {
+    readonly file: string;
+    readonly source: string;
+}): string;
+/** Where one extension's declaration lives, relative to the project root, POSIX. */
+declare function declarationPath(name: string): string;
+interface WriteDeclarationOptions extends DeclarationSubject {
+    readonly root: string;
+    /** The installed package directory, read for the declaration it ships. */
+    readonly dir: string;
+    readonly types: string | undefined;
+}
+/** Writes the declaration and answers with the path a message prints. */
+declare function writeDeclaration(options: WriteDeclarationOptions): string;
+
+/**
+ * `$PENV_HOME` — the one directory the launcher owns.
+ *
+ * Engines and extensions are addressed by exact name and exact version, so a
+ * machine holds every version any of its projects pins at once and no project's
+ * command is ever answered by another project's bytes.
+ */
+/** A read-only view of the process environment. */
+type Environment = Readonly<Record<string, string | undefined>>;
+/** The variable that moves the store off `~/.penv`. */
+declare const PENV_HOME_VAR = "PENV_HOME";
+/** The two things the store holds, and the directory each lives under. */
+type PackageKind = "engines" | "extensions";
+/** How the launcher was installed, recorded by the installer that did it. */
+declare const HOME_META_FILE = "meta.json";
+/** Written beside an installed package: the SSRI of the tarball it came from. */
+declare const INTEGRITY_FILE = ".penv-integrity";
+/** The update command for a launcher whose installer recorded nothing. */
+declare const NPM_UPDATE_COMMAND = "npm install -g @penvhq/launcher";
+/** The store, from the environment. `~/.penv` unless `$PENV_HOME` says otherwise. */
+declare function penvHome(env: Environment): string;
+/**
+ * Where one exact version lives.
+ *
+ * The manifest's grammar already refuses a name or a version that could climb
+ * out of the store, so the containment check is the second lock rather than the
+ * first: this function is also reached from `penv add`, where the name is
+ * whatever the user typed.
+ *
+ * Containment is measured against the bucket, not against `$PENV_HOME`. A name
+ * of `../extensions/x` stays inside the store while landing an engine among the
+ * extensions, and a store where the two are not separated is a store where the
+ * kind a caller asked for is not the kind it gets.
+ */
+declare function packageDir(home: string, kind: PackageKind, name: string, version: string): string;
+/**
+ * The command that updates this launcher.
+ *
+ * Advisory, so it never throws: a store with no `meta.json`, or one holding
+ * something unreadable, falls back to the npm form rather than turning a
+ * manifest-format refusal into a second failure about a metadata file.
+ */
+declare function launcherUpdateCommand(home: string): string;
+
+/**
+ * Handing the command over.
+ *
+ * The engine is a child process, not an import: it is a different version of
+ * penv than the launcher, and it has to be able to be. What crosses is the
+ * argument list exactly as typed, the three streams, the exit code, and the
+ * signal that ended it — nothing is parsed, rewritten, or summarized on the way.
+ */
+
+interface Delegation {
+    /** The executable to run — node, for a JS engine entry. */
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: Environment;
+}
+/** Runs the child and answers with the exit code the caller should exit with. */
+type Spawner = (delegation: Delegation) => Promise<number>;
+declare function nodeSpawner(): Spawner;
+
+/**
+ * Turning an installed directory into something to run.
+ *
+ * The engine that ships with the launcher and the engine a project pins are the
+ * same kind of thing — a package directory with a `bin` — so there is one
+ * resolver and one spawn path, and `penv init` outside a project takes exactly
+ * the route `penv get` takes inside one.
+ */
+/** The bin name the engine publishes. `penv` itself belongs to the launcher. */
+declare const ENGINE_BIN = "penv-engine";
+interface Engine {
+    readonly name: string;
+    readonly version: string;
+    readonly dir: string;
+    /** The JS file to hand to node, absolute. */
+    readonly entry: string;
+}
+/**
+ * The engine installed at `dir`, or the refusal that says it is not runnable.
+ *
+ * `bin` comes out of the package's own `package.json`, so it is checked for
+ * containment like every other path the launcher resolves from something it did
+ * not write: a `bin` of `../../x.js` names a file penv would hand to node from
+ * outside the package the manifest pinned.
+ */
+declare function engineAt(dir: string, name: string, version: string): Engine;
+/**
+ * The engine that shipped with this launcher — the one that runs `init` in a
+ * directory that is not a project yet.
+ *
+ * It is resolved rather than bundled: a launcher installed from npm gets the
+ * engine as a dependency, which is what makes it a package directory with a
+ * `bin` like every other engine in the store.
+ */
+declare function bundledEngine(): Engine;
+
+/**
+ * What the launcher refuses, and the one command that clears each refusal.
+ *
+ * Every one of these is a wrong-bytes or no-bytes answer to the same question —
+ * which penv is this project's — so they all name the package, the version, and
+ * a single next command. Only the two engine-pin refusals mention the
+ * launcher/engine split, because a launcher that cannot record which engine it
+ * ran is the one failure that cannot be described without it; the rest name a
+ * package and a command, and leave penv looking like one program.
+ */
+
+/** The command that materializes everything the manifest pins. */
+declare const INSTALL_COMMAND = "penv install";
+/** How long a package outside the official scope must have existed. */
+declare const MIN_PACKAGE_AGE_DAYS = 7;
+/** The flag that overrides {@link MIN_PACKAGE_AGE_DAYS}, and only that. */
+declare const TRUST_YOUNG_FLAG = "--trust-young";
+/** The command was typed outside any penv project. */
+declare class NoProjectError extends PenvError {
+    readonly name = "NoProjectError";
+    constructor(cwd: string);
+}
+/** The pinned bytes are not on this machine, and this run does not download. */
+declare class PackageMissingError extends PenvError {
+    readonly name = "PackageMissingError";
+    constructor(name: string, version: string, home: string);
+}
+/** The bytes on this machine are not the bytes the manifest pins. */
+declare class PackageCorruptError extends PenvError {
+    readonly name = "PackageCorruptError";
+    constructor(name: string, version: string, dir: string);
+}
+/** The download was offered and declined. */
+declare class InstallDeclinedError extends PenvError {
+    readonly name = "InstallDeclinedError";
+    constructor(name: string, version: string);
+}
+/** The registry could not be reached, or answered with something other than the tarball. */
+declare class DownloadFailedError extends PenvError {
+    readonly name = "DownloadFailedError";
+    constructor(name: string, version: string, url: string, detail: string);
+}
+/** The registry served bytes the manifest does not pin. Nothing is installed. */
+declare class DownloadIntegrityError extends PenvError {
+    readonly name = "DownloadIntegrityError";
+    constructor(name: string, version: string, url: string);
+}
+/** An archive entry penv will not write to disk. */
+declare class ArchiveError extends PenvError {
+    readonly name = "ArchiveError";
+    constructor(name: string, version: string, entry: string);
+}
+/** `penv add` with nothing to add. */
+declare class AddSubjectError extends PenvError {
+    readonly name = "AddSubjectError";
+    constructor();
+}
+/** A package name npm would not recognise. */
+declare class AddPackageNameError extends PenvError {
+    readonly name = "AddPackageNameError";
+    constructor(spec: string);
+}
+/** A flag `penv add` does not have. */
+declare class AddFlagError extends PenvError {
+    readonly name = "AddFlagError";
+    constructor(flag: string);
+}
+/** `--registry` with something that is not an https origin. */
+declare class AddRegistryError extends PenvError {
+    readonly name = "AddRegistryError";
+    constructor(value: string);
+}
+/** penv's own packages, offered by a registry that is not npmjs. */
+declare class OfficialRegistryError extends PenvError {
+    readonly name = "OfficialRegistryError";
+    constructor(name: string, registry: string);
+}
+/** The registry could not be read at all. */
+declare class RegistryUnreadableError extends PenvError {
+    readonly name = "RegistryUnreadableError";
+    constructor(name: string, url: string, detail: string);
+}
+/** The registry has no such package. */
+declare class PackageUnknownError extends PenvError {
+    readonly name = "PackageUnknownError";
+    constructor(name: string, url: string);
+}
+/** The package exists; the version asked for does not. */
+declare class VersionUnknownError extends PenvError {
+    readonly name = "VersionUnknownError";
+    constructor(name: string, version: string, url: string);
+}
+/** The registry answered, but without a fact the manifest has to record. */
+declare class ReleaseIncompleteError extends PenvError {
+    readonly name = "ReleaseIncompleteError";
+    constructor(name: string, version: string, url: string, missing: string);
+}
+/** A third-party package younger than the age gate, with no override. */
+declare class PackageTooYoungError extends PenvError {
+    readonly name = "PackageTooYoungError";
+    constructor(name: string, version: string, publishedAt: string);
+}
+/** `penv add` needs the registry, and `--no-download` says this run has no network. */
+declare class AddNoDownloadError extends PenvError {
+    readonly name = "AddNoDownloadError";
+    constructor(name: string);
+}
+/**
+ * `penv add` on a machine with nobody at it.
+ *
+ * It is refused everywhere, not only for the packages that pay the trust
+ * ceremony: what `add` writes is two committed files, and a pipeline that
+ * rewrites the manifest it was handed is a pipeline choosing which bytes the
+ * project runs. `penv install` is the command CI has, and it installs exactly
+ * what a person already decided.
+ */
+declare class AddNotInteractiveError extends PenvError {
+    readonly name = "AddNotInteractiveError";
+    constructor(name: string);
+}
+/** The trust ceremony was declined. Nothing was installed or recorded. */
+declare class TrustDeclinedError extends PenvError {
+    readonly name = "TrustDeclinedError";
+    constructor(name: string, version: string);
+}
+/** A third-party trust block with nobody named in it. */
+declare class TrustPublisherMissingError extends PenvError {
+    readonly name = "TrustPublisherMissingError";
+    constructor(name: string, version: string);
+}
+/** The trust block's one human field came back empty. */
+declare class TrustReasonMissingError extends PenvError {
+    readonly name = "TrustReasonMissingError";
+    constructor(name: string, version: string);
+}
+/** `penv.types` names a file the published package does not contain. */
+declare class DeclarationMissingError extends PenvError {
+    readonly name = "DeclarationMissingError";
+    constructor(name: string, file: string);
+}
+/** The declaration a package ships reaches for something the project does not have. */
+declare class DeclarationNotSelfContainedError extends PenvError {
+    readonly name = "DeclarationNotSelfContainedError";
+    constructor(name: string, file: string, specifier: string);
+}
+/** A launcher built from source, asked to record which bytes it just ran. */
+declare class EnginePinUnreleasedError extends PenvError {
+    readonly name = "EnginePinUnreleasedError";
+    constructor();
+}
+/** The pin embedded at release time and the engine beside it are different versions. */
+declare class EnginePinMismatchError extends PenvError {
+    readonly name = "EnginePinMismatchError";
+    constructor(pinned: string, ran: string);
+}
+/** An installed directory with nothing runnable in it. */
+declare class EngineEntryError extends PenvError {
+    readonly name = "EngineEntryError";
+    constructor(name: string, version: string, dir: string);
+}
+
+/**
+ * The one hash penv checks: npm's SSRI, over the tarball bytes.
+ *
+ * The manifest pins the same string npm recorded, so the value compared here is
+ * the value a reviewer approved in the diff — not a digest penv invented.
+ */
+/** The SSRI of some bytes, in the form the manifest pins. */
+declare function integrityOf(bytes: Uint8Array): string;
+
+/**
+ * The launcher protocol.
+ *
+ * One question is asked on every invocation — which penv is this project's — and
+ * everything here is the answer to it: find the manifest, read only the format
+ * it declares, prove the pinned bytes are on this machine, hand the command
+ * over. The launcher parses `--no-download` and `--version` and nothing else;
+ * every other token is the engine's business and crosses untouched.
+ *
+ * Downloading is the one behavior that differs by where penv is running. CI and
+ * production never download during a run — they refuse and name the command that
+ * installs — because a production start that is also a network event is a
+ * production start that can fail for a reason nobody chose.
+ */
+
+interface LauncherOptions {
+    /** The command line, minus the executable — `process.argv.slice(2)`. */
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: Environment;
+    readonly io: LauncherIo;
+    readonly fetcher: Fetcher;
+    readonly spawn: Spawner;
+    /** The engine that shipped with this launcher, resolved only when it is needed. */
+    readonly bundledEngine: () => Engine;
+    /** That engine's published identity, embedded at release time. */
+    readonly bundledPin: ManifestEngine;
+}
+declare function runLauncher(options: LauncherOptions): Promise<number>;
+
+/**
+ * The published identity of the engine that ships with this launcher.
+ *
+ * A manifest pins bytes, and bytes are named by the SSRI npm recorded for the
+ * tarball — which nothing can compute from an installed directory, and which
+ * `init` may not go and ask for, because adoption is offline. So the launcher
+ * carries the answer: the release pipeline publishes `@penvhq/cli`, reads that
+ * integrity from the registry, writes it here, and only then publishes `penv`.
+ * The pin and the engine beside it describe one release or the launcher refuses
+ * to use either.
+ *
+ * The value checked into this repository is a placeholder that no registry could
+ * ever serve, and {@link assertReleasePin} is the gate that keeps it out of a
+ * published launcher and out of anyone's project.
+ */
+
+/** Deliberately not an SSRI: nothing can install, or verify, what it names. */
+declare const DEV_PIN_INTEGRITY = "sha512-development-build-not-a-published-release";
+/** The version that goes with it, equally unpublishable. */
+declare const DEV_PIN_VERSION = "0.0.0-dev";
+/** Rewritten by the release step, after `@penvhq/cli` is on the registry. */
+declare const BUNDLED_ENGINE_PIN: ManifestEngine;
+/** The release gate: a launcher built from source has nothing to pin. */
+declare function assertReleasePin(pin: ManifestEngine): void;
+/** The pin for the engine that just ran, or the refusal that says there is none. */
+declare function releaseEnginePin(pin: ManifestEngine, ranVersion: string): ManifestEngine;
+
+/**
+ * Finding the project a command was typed in.
+ *
+ * The manifest is the marker, not `penv.config.ts`: the launcher's whole job is
+ * to run the engine the project pins, and the manifest is the file that pins it.
+ * A checkout whose `node_modules` has never been installed still answers.
+ */
+interface Project {
+    /** The directory holding `.penv/`. */
+    readonly root: string;
+    /** The manifest, absolute. */
+    readonly manifestFile: string;
+}
+/** The nearest project at or above `cwd`, or `undefined` outside one. */
+declare function findProject(cwd: string): Project | undefined;
+/**
+ * The project a delegated `init` or `migrate` left behind, recognised by the
+ * state directory rather than the manifest it does not have yet.
+ *
+ * A command that previewed and wrote nothing leaves none, which is what keeps a
+ * `penv migrate` typed in an ordinary directory from being handed a manifest.
+ */
+declare function findAdoptedRoot(cwd: string): string | undefined;
+
+/**
+ * What the registry says about one release.
+ *
+ * Everything `add` decides from — the exact version behind `latest`, the
+ * integrity of the bytes, when it was published, who published it, whether npm
+ * holds a provenance attestation — is metadata, so it arrives through the same
+ * fetcher the tarball does. One network seam, and a test suite that serves both
+ * from memory.
+ */
+
+/** One published version, reduced to the facts a trust decision is made on. */
+interface Release {
+    readonly name: string;
+    readonly version: string;
+    readonly integrity: string;
+    /** ISO 8601, as the registry's `time` map records it. */
+    readonly publishedAt: string;
+    /** The npm account credited with the publish, when the registry names one. */
+    readonly publisher: string | undefined;
+    /** Whether npm holds a provenance attestation for these exact bytes. */
+    readonly attested: boolean;
+}
+interface ReleaseQuery {
+    readonly name: string;
+    /** Absent means whatever `latest` points at today. */
+    readonly version?: string;
+    /** Only when the package comes from somewhere other than npmjs. */
+    readonly registry?: string;
+    readonly fetcher: Fetcher;
+}
+/** The packument's address, which an exact name can be built rather than searched. */
+declare function packumentUrl(registry: string | undefined, name: string): string;
+/** The one release `add` is about to decide on, or why the registry could not say. */
+declare function fetchRelease(query: ReleaseQuery): Promise<Release>;
+
+/**
+ * The store: what is installed, and how something absent gets installed.
+ *
+ * An installed package carries the SSRI of the tarball it came from, written
+ * beside it at install time, so every later run compares the manifest's pin
+ * against a recorded answer instead of re-hashing a directory that would never
+ * hash to an npm integrity anyway. Three states, and only three: the bytes the
+ * manifest pins, no bytes, or bytes that are not the ones pinned.
+ */
+
+/** One exact thing the manifest names. */
+interface Pin {
+    readonly name: string;
+    readonly version: string;
+    readonly integrity: string;
+    /** Only when the package comes from somewhere other than npmjs. */
+    readonly registry?: string;
+}
+/** Where penv looks when a pin names no registry. */
+declare const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+type InstallState = "installed" | "absent" | "corrupt";
+interface Installation {
+    readonly dir: string;
+    readonly state: InstallState;
+}
+/** npm's tarball address, which an exact version can be built rather than looked up. */
+declare function tarballUrl(pin: Pin): string;
+/** What this machine holds for one pin. */
+declare function inspectInstall(home: string, kind: PackageKind, pin: Pin): Installation;
+interface InstallOptions {
+    readonly home: string;
+    readonly kind: PackageKind;
+    readonly pin: Pin;
+    readonly fetcher: Fetcher;
+}
+/**
+ * Downloads one pin, verifies it, and installs it — in that order, and never a
+ * different one.
+ *
+ * The extraction happens in a staging directory and arrives by rename, so an
+ * interrupted install leaves nothing that a later run could read as installed.
+ */
+declare function installPin(options: InstallOptions): Promise<string>;
+
+/**
+ * The npm tarball reader.
+ *
+ * An npm package is a gzipped ustar archive whose every path begins `package/`,
+ * so this reads exactly that and refuses everything else: no symlinks, no
+ * hardlinks, no absolute paths, no `..`, nothing outside `package/`. The
+ * checksum in each header is not verified because the SSRI over the whole
+ * tarball already was, before a single block was read.
+ */
+/** One regular file, at its path relative to the package root. */
+interface TarEntry {
+    readonly path: string;
+    readonly bytes: Uint8Array;
+}
+/** The package a refusal names. */
+interface ArchiveSubject {
+    readonly name: string;
+    readonly version: string;
+}
+/** Every regular file in an npm tarball, `package/` stripped. */
+declare function readTarball(gzipped: Uint8Array, subject: ArchiveSubject): TarEntry[];
+
+export { AddFlagError, AddNoDownloadError, AddNotInteractiveError, type AddOptions, AddPackageNameError, AddRegistryError, type AddResult, AddSubjectError, ArchiveError, type ArchiveSubject, BUNDLED_ENGINE_PIN, DEFAULT_REGISTRY, DEV_PIN_INTEGRITY, DEV_PIN_VERSION, DeclarationMissingError, DeclarationNotSelfContainedError, type DeclarationSubject, type Delegation, DownloadFailedError, DownloadIntegrityError, ENGINE_BIN, type Engine, EngineEntryError, EnginePinMismatchError, EnginePinUnreleasedError, type Environment, type ExtensionPackage, type Fetcher, HOME_META_FILE, INSTALL_COMMAND, INTEGRITY_FILE, InstallDeclinedError, type InstallOptions, type InstallState, type Installation, type LauncherIo, type LauncherOptions, MIN_PACKAGE_AGE_DAYS, NPM_UPDATE_COMMAND, NoProjectError, OfficialRegistryError, PENV_HOME_VAR, PackageCorruptError, type PackageKind, PackageMissingError, PackageTooYoungError, PackageUnknownError, type Pin, type Project, type ProviderEntry, RegistryUnreadableError, type Release, ReleaseIncompleteError, type ReleaseQuery, type Spawner, TRUST_YOUNG_FLAG, type TarEntry, 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 };