@b-apm/core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,4048 @@
+import { IntegrationRegistry, MarketplaceOutputRegistry, MaterializeReport, McpServerConfig } from "@b-apm/integration-api";
+//#region src/modules/Manifest/errors.d.ts
+/** Typed diagnostics for manifest discovery / YAML load / validate. */
+type ManifestErrorCode = "MANIFEST_NOT_FOUND" | "MANIFEST_DUAL_CONFLICT" | "MANIFEST_MISSING_FILE" | "MANIFEST_YAML_PARSE" | "MANIFEST_YAML_SAFE_SUBSET" | "MANIFEST_VALIDATION";
+declare class ManifestError extends Error {
+  readonly code: ManifestErrorCode;
+  readonly path?: string;
+  readonly details?: Record<string, unknown>;
+  constructor(code: ManifestErrorCode, message: string, options?: {
+    path?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+type ManifestWarning = {
+  code: string;
+  message: string;
+  path?: string;
+};
+//#endregion
+//#region src/modules/Manifest/types.d.ts
+/** Declared agentic dependency (APM package, skill path, plugin, MCP server, …). */
+type BapmDependency = {
+  /** Spec string, e.g. `org/repo`, `org/repo/path`, `org/repo#v1.0.0`. */
+  spec: string;
+  kind?: "apm" | "mcp" | "skill" | "plugin" | "primitive";
+};
+/**
+ * Object-form APM dependency. Source discriminators `git` | `id` | `path` |
+ * `registry` | `marketplace` | `local` are mutually exclusive, except `path` may
+ * accompany `git` as a virtual_path companion (`git: parent` requires `path`).
+ * `local` is a bapm extension (default `.agents/local`); it MUST NOT replace the
+ * git virtual_path companion role.
+ */
+type ObjectDependency = {
+  git?: string;
+  id?: string;
+  path?: string;
+  registry?: string;
+  /** Marketplace alias for `{ name, marketplace, version? }` form. */
+  marketplace?: string;
+  /**
+   * Bapm-only local source: `true` | `null` | `""` → default `.agents/local`;
+   * non-empty string → custom path. Rejected: `false` and non-scalars.
+   */
+  local?: boolean | string | null;
+  name?: string;
+  version?: string;
+  ref?: string;
+  alias?: string;
+  skills?: unknown;
+  [key: string]: unknown;
+};
+type DependencyEntry = string | ObjectDependency | BapmDependency;
+/** Dependency list keys under `dependencies` / `devDependencies`. */
+type DependencyLists = {
+  apm?: DependencyEntry[];
+  mcp?: unknown[];
+  lsp?: unknown[];
+  [key: string]: unknown;
+};
+type RegistryEntry = {
+  url: string;
+  /** Allow remote `http://` registry URL (OpenAPM §4.2.3 / sc-006). */
+  insecure?: boolean;
+  /** Explicit hostnames that share this registry URL's credential host-class (sc-005). */
+  aliases?: string[];
+  [key: string]: unknown;
+};
+type ManifestFilename = "apm.yml" | "bapm.yml";
+/**
+ * Bapm-extension host id → npm integration package specifier map
+ * (`target` / `targets` object form). Keys are mf-005 tokens; values are
+ * opaque non-empty package strings (not loaded by install in this slice).
+ */
+type TargetIntegrationMap = Record<string, string>;
+/**
+ * In-memory project manifest. Known fields are typed; unknown top-level and
+ * `x-*` keys are retained on the same object for a future rewrite path.
+ */
+type BapmManifest = {
+  name: string;
+  version: string;
+  dependencies?: DependencyLists;
+  devDependencies?: DependencyLists;
+  registries?: Record<string, RegistryEntry | string>;
+  default_host?: string;
+  /**
+   * Host preference: legacy single id string, or object-map host→package
+   * (mutually exclusive with `targets`). Vendor ids `x-<vendor>-<name>` allowed.
+   */
+  target?: string | TargetIntegrationMap;
+  /**
+   * Host preferences: legacy string array, or object-map host→package
+   * (mutually exclusive with `target`). Prefer this field for multi-host maps.
+   */
+  targets?: string[] | TargetIntegrationMap;
+  /**
+   * Bapm extension: non-empty list of mf-005 host ids to activate for
+   * materialize/MCP (multi) or compile (sole). Distinct from `target`/`targets`.
+   */
+  active?: string[];
+  /**
+   * Optional bake / placeholder defaults (string map). Deep-merged from
+   * `bapm.local.yml` when present (local keys win).
+   */
+  env?: Record<string, string>;
+  [key: string]: unknown;
+};
+type DiscoverManifestOptions = {
+  /** Project root; defaults to `process.cwd()`. No parent walk-up. */
+  cwd?: string;
+  /** Explicit manifest path; wins over discovery. */
+  path?: string;
+};
+type DiscoveredManifest = {
+  path: string;
+  /** Basename of the loaded file (`apm.yml` / `bapm.yml`, or explicit path basename). */
+  filename: string;
+};
+type LoadManifestOptions = DiscoverManifestOptions;
+type LoadManifestResult = {
+  /** Validated document retaining unknown / `x-*` keys. */
+  document: BapmManifest;
+  sourcePath: string;
+  sourceFilename: string;
+  /** Absolute path to `bapm.local.yml` when an overlay was merged. */
+  localPath?: string;
+  warnings?: ManifestWarning[];
+};
+//#endregion
+//#region src/modules/Manifest/discover.d.ts
+declare const APM_MANIFEST_FILE = "apm.yml";
+declare const BAPM_MANIFEST_FILE = "bapm.yml";
+/**
+ * Resolve which manifest file to load.
+ * Explicit `path` wins; otherwise exactly one of apm.yml / bapm.yml at cwd.
+ * Does not walk parent directories.
+ */
+declare function discoverManifestPath(options?: DiscoverManifestOptions): DiscoveredManifest;
+//#endregion
+//#region src/modules/Manifest/load.d.ts
+/**
+ * Discover → read base dual-read file → safe YAML → validate.
+ * Does **not** merge `bapm.local.yml` (use `loadEffectiveManifest` / `loadManifest` for that).
+ * Suitable for publish/pack wire identity serialization.
+ */
+declare function loadBaseManifest(options?: LoadManifestOptions): LoadManifestResult;
+/**
+ * Load validated base dual-read manifest, then optionally merge `bapm.local.yml`.
+ * Precedence for settings: CLI flags (call-site) → local overlay → base → env overrides.
+ */
+declare function loadEffectiveManifest(options?: LoadManifestOptions): LoadManifestResult;
+/**
+ * Discover → read file → safe YAML → validate → merge optional personal overlay.
+ * Does not resolve, lock, download, or install.
+ */
+declare function loadManifest(options?: LoadManifestOptions): LoadManifestResult;
+//#endregion
+//#region src/modules/Manifest/localOverlay.d.ts
+declare const BAPM_LOCAL_MANIFEST_FILE = "bapm.local.yml";
+/** Unsupported dual-brand local overlay filename (v1 refuse). */
+declare const APM_LOCAL_MANIFEST_FILE = "apm.local.yml";
+type LocalOverlayFields = {
+  active?: string[];
+  target?: string | TargetIntegrationMap;
+  targets?: string[] | TargetIntegrationMap;
+  env?: Record<string, string>;
+  registries?: Record<string, RegistryEntry | string>;
+};
+/**
+ * Validate overlay YAML: mapping + allowlist + field shapes (via stub parse).
+ */
+declare function parseLocalOverlayDocument(input: unknown, sourcePath?: string): LocalOverlayFields;
+/**
+ * Merge allowlisted local fields over a validated base document, then re-validate.
+ */
+declare function mergeLocalOverlay(base: BapmManifest, overlay: LocalOverlayFields): BapmManifest;
+//#endregion
+//#region src/modules/Manifest/parse.d.ts
+type ParseManifestResult = {
+  document: BapmManifest;
+  warnings: ManifestWarning[];
+};
+/**
+ * Validate top-level (or overlay) `env` as string→string with env-safe keys.
+ * Empty string values are allowed (shape); bake still requires non-empty at lookup.
+ */
+declare function validateManifestEnv(value: unknown, pathPrefix?: string): Record<string, string>;
+/**
+ * Validate a pre-parsed JS value as an OpenAPM/APM project manifest.
+ * Retains unknown top-level and `x-*` keys on the returned document.
+ */
+declare function parseManifestDocument(input: unknown): ParseManifestResult;
+/** Back-compat entry for already-loaded JS objects. */
+declare function parseManifest(input: unknown): BapmManifest;
+//#endregion
+//#region src/modules/Manifest/yaml-load.d.ts
+/**
+ * Public YAML loader for Manifest consumers.
+ * Wraps common safe-subset loader and maps YamlError → ManifestError.
+ */
+declare function loadYamlDocument(source: string, sourcePath?: string): unknown;
+//#endregion
+//#region src/modules/Manifest/write.d.ts
+type WriteManifestOptions = {
+  cwd?: string;
+  /** Explicit destination path (overrides write-back / discovery). */
+  path?: string;
+  /** Loaded filename for same-brand write-back. */
+  sourceFilename?: string;
+  /** Absolute path that was loaded; preferred write-back target. */
+  sourcePath?: string;
+};
+type WriteProducerManifestOptions = WriteManifestOptions & {
+  /** Optional sink for non-blocking warnings (e.g. mf-004). */
+  onWarning?: (warning: ManifestWarning) => void;
+};
+type WriteProducerManifestResult = {
+  path: string;
+  warnings: ManifestWarning[];
+};
+/**
+ * Serialize a manifest document to YAML (round-trip best-effort).
+ */
+declare function serializeManifest(document: BapmManifest | Record<string, unknown>): string;
+/**
+ * Write manifest YAML back to the discovered dual-read path (or explicit path).
+ * Does not validate — prefer {@link writeProducerManifest} for producer emit.
+ */
+declare function writeManifest(document: BapmManifest | Record<string, unknown>, options?: WriteManifestOptions): string;
+/**
+ * Producer write path: parse/validate before durable emit (mf-*).
+ * Preserves vendor `x-*` keys; mf-004 non-semver is a non-blocking warning.
+ */
+declare function writeProducerManifest(document: BapmManifest | Record<string, unknown>, options?: WriteProducerManifestOptions): WriteProducerManifestResult;
+/** Aliases for acceptance / design naming flexibility. */
+declare const emitManifest: typeof writeProducerManifest;
+declare const writeManifestValidated: typeof writeProducerManifest;
+//#endregion
+//#region src/modules/Manifest/createMinimal.d.ts
+type CreateMinimalManifestOptions = {
+  /** Package / project name (required, non-empty). */
+  name: string;
+  /** Semver-shaped version; defaults to `0.1.0`. */
+  version?: string;
+  /** Single host target (mutually exclusive with `targets`). */
+  target?: string;
+  /** Multi host targets or object-map (mutually exclusive with `target`). */
+  targets?: string[] | TargetIntegrationMap;
+  /** Optional active host ids for materialize/compile selection. */
+  active?: string[];
+  description?: string;
+  author?: string;
+  /**
+   * When true, emit plugin-mode scaffold fields:
+   * `devDependencies.apm`, `includes: auto`, `scripts: {}`.
+   * Consumer / default path remains unchanged when omitted/false.
+   */
+  pluginMode?: boolean;
+};
+/**
+ * Build a minimal conforming producer manifest (mf-001..003, mf-021).
+ * Never includes top-level `workspaces`.
+ */
+declare function createMinimalManifest(options: CreateMinimalManifestOptions): BapmManifest;
+/** Alias accepted by acceptance helpers. */
+declare const createMinimalManifestDocument: typeof createMinimalManifest;
+//#endregion
+//#region src/modules/Manifest/pluginNames.d.ts
+/**
+ * Validate a kebab-case plugin name (`^[a-z][a-z0-9-]{0,63}$`).
+ * Returns `{ ok: true }` or `{ ok: false, message }`.
+ */
+declare function validatePluginName(name: string): {
+  ok: true;
+} | {
+  ok: false;
+  message: string;
+};
+/**
+ * Path-safe project / subdirectory name for plugin init.
+ * Rejects empty, path separators (`/`, `\`), and `..` segments.
+ */
+declare function validateProjectName(name: string): {
+  ok: true;
+} | {
+  ok: false;
+  message: string;
+};
+/** Boolean alias for callers that prefer a simple predicate. */
+declare function isValidPluginName(name: string): boolean;
+/** Boolean alias for callers that prefer a simple predicate. */
+declare function isValidProjectName(name: string): boolean;
+//#endregion
+//#region src/modules/Manifest/pluginJson.d.ts
+type PluginJsonAuthor = {
+  name: string;
+};
+type CreatePluginJsonOptions = {
+  name: string;
+  version?: string;
+  description?: string;
+  author?: PluginJsonAuthor;
+  license?: string;
+};
+type PluginJsonDocument = {
+  name: string;
+  version: string;
+  description: string;
+  author: PluginJsonAuthor;
+  license: string;
+};
+type WritePluginJsonOptions = CreatePluginJsonOptions & {
+  cwd?: string;
+  /** Explicit destination path (defaults to `<cwd>/plugin.json`). */
+  path?: string;
+};
+/**
+ * Build an in-memory `plugin.json` document (APM-shaped thin scaffold).
+ */
+declare function createPluginJson(options: CreatePluginJsonOptions): PluginJsonDocument;
+/** Alias accepted by acceptance helpers. */
+declare const createPluginJsonDocument: typeof createPluginJson;
+declare const buildPluginJson: typeof createPluginJson;
+/**
+ * Serialize `plugin.json` with indent width 2 and a trailing newline.
+ */
+declare function serializePluginJson(document: PluginJsonDocument | Record<string, unknown>): string;
+/**
+ * Write `plugin.json` to disk (indent 2 + trailing newline). Offline only.
+ */
+declare function writePluginJson(options: WritePluginJsonOptions): string;
+/** Aliases for acceptance naming flexibility. */
+declare const writePluginJsonFile: typeof writePluginJson;
+declare const emitPluginJson: typeof writePluginJson;
+//#endregion
+//#region src/modules/Manifest/targets.d.ts
+/**
+ * OpenAPM mf-005 target / targets token validation.
+ * Canonical set + legacy aliases from OpenAPM v0.1 §4.2.1.
+ */
+/** Canonical host ids registered by OpenAPM v0.1. */
+declare const CANONICAL_TARGET_TOKENS: Set<string>;
+/** Legacy aliases accepted on input (normalised by writers elsewhere). */
+declare const TARGET_ALIAS_TOKENS: Set<string>;
+/** Vendor extension: `x-<vendor>-<name>` (OpenAPM req-mf-005). */
+declare const VENDOR_TARGET_RE: RegExp;
+declare function isValidTargetToken(token: string): boolean;
+//#endregion
+//#region src/modules/Manifest/registryUrl.d.ts
+/**
+ * Registry URL http gate helpers (OpenAPM §4.2.3 / sc-006).
+ */
+/** Loopback, localhost, ::1, and RFC1918 private hosts — http allowed without insecure. */
+declare function isExemptInsecureHost(hostname: string): boolean;
+//#endregion
+//#region src/modules/Lockfile/types.d.ts
+/** Declared lock dependency entry (OpenAPM §5 / APM LockedDependency wire). */
+type LockedDependency = {
+  repo_url: string;
+  materialization_repo_url?: string;
+  name?: string;
+  version?: string;
+  source?: string;
+  resolved_commit?: string;
+  /** Pin identity used for resolve / outdated tip (branch, tag, SHA, or HEAD). */
+  resolved_ref?: string;
+  resolved_url?: string;
+  resolved_hash?: string;
+  virtual_path?: string;
+  constraint?: string;
+  resolved_tag?: string;
+  resolved_at?: string;
+  tree_sha256?: string;
+  deployed_files?: string[];
+  deployed_file_hashes?: Record<string, string>;
+  [key: string]: unknown;
+};
+/**
+ * In-memory lockfile document. Known fields are typed; unknown top-level and
+ * `x-*` keys (incl. deployments / lsp_* / MCP lists) are retained for round-trip.
+ */
+type LockfileDocument = {
+  lockfile_version: "1" | "2";
+  dependencies: LockedDependency[];
+  generated_at?: string;
+  apm_version?: string | number;
+  local_deployed_files?: string[];
+  local_deployed_file_hashes?: Record<string, string>;
+  [key: string]: unknown;
+};
+type LockFilename = string;
+/**
+ * Loose document bag accepted by serialize/write/equivalence (acceptance helpers
+ * extract via `lockOf()` as `Record<string, unknown>`).
+ */
+type LockfileInput = LockfileDocument | Record<string, unknown>;
+type DiscoverLockfileOptions = {
+  /** Project root; defaults to `process.cwd()`. No parent walk-up. */
+  cwd?: string;
+  /** Explicit lockfile path; wins over discovery. */
+  path?: string;
+};
+type DiscoveredLockfile = {
+  path: string;
+  /** Basename of the resolved file (`apm.lock.yaml` / `bapm.lock.yaml`, or explicit). */
+  filename: string;
+};
+type LoadLockfileOptions = DiscoverLockfileOptions;
+type LoadLockfileResult = {
+  /** Validated document retaining unknown / `x-*` keys. */
+  document: LockfileDocument;
+  sourcePath: string;
+  sourceFilename: string;
+};
+type WriteLockfileOptions = {
+  cwd?: string;
+  /** Explicit destination path (overrides write-back / fresh default). */
+  path?: string;
+  /** Loaded filename for same-brand write-back. */
+  sourceFilename?: string;
+  /** Absolute path that was loaded; preferred write-back target. */
+  sourcePath?: string;
+};
+//#endregion
+//#region src/modules/Lockfile/errors.d.ts
+/** Typed diagnostics for lockfile discovery / YAML load / validate / write. */
+type LockfileErrorCode = "LOCKFILE_NOT_FOUND" | "LOCKFILE_DUAL_CONFLICT" | "LOCKFILE_MISSING_FILE" | "LOCKFILE_YAML_PARSE" | "LOCKFILE_YAML_SAFE_SUBSET" | "LOCKFILE_FORMAT" | "LOCKFILE_UNSUPPORTED_VERSION" | "LOCKFILE_VALIDATION";
+declare class LockfileError extends Error {
+  readonly code: LockfileErrorCode;
+  readonly path?: string;
+  readonly details?: Record<string, unknown>;
+  constructor(code: LockfileErrorCode, message: string, options?: {
+    path?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Lockfile/discover.d.ts
+declare const APM_LOCK_FILE = "apm.lock.yaml";
+declare const BAPM_LOCK_FILE = "bapm.lock.yaml";
+/**
+ * Resolve which lockfile to load.
+ * Explicit `path` wins; otherwise exactly one of apm.lock.yaml / bapm.lock.yaml at cwd.
+ * Does not walk parent directories. Ignores legacy `apm.lock`.
+ */
+declare function discoverLockfilePath(options?: DiscoverLockfileOptions): DiscoveredLockfile;
+//#endregion
+//#region src/modules/Lockfile/load.d.ts
+/**
+ * Discover → read file → safe YAML → validate.
+ * Does not resolve, download, or install.
+ */
+declare function loadLockfile(options?: LoadLockfileOptions): LoadLockfileResult;
+/**
+ * Like `loadLockfile`, but returns `null` when neither brand file exists.
+ * Dual-conflict and corrupt/invalid files still throw.
+ */
+declare function loadLockfileOrNull(options?: LoadLockfileOptions): LoadLockfileResult | null;
+/**
+ * Write lockfile YAML to disk.
+ * - Explicit `path` wins
+ * - Else write-back to `sourcePath` / `sourceFilename` when provided
+ * - Else fresh create → `bapm.lock.yaml` under `cwd`
+ */
+declare function writeLockfile(document: LockfileInput, options?: WriteLockfileOptions): string;
+//#endregion
+//#region src/modules/Lockfile/parse.d.ts
+/**
+ * Validate a pre-parsed JS value as an OpenAPM/APM lockfile document.
+ * Retains unknown top-level and per-entry keys (incl. `x-*`).
+ */
+declare function parseLockfileDocument(input: unknown): LockfileDocument;
+/**
+ * Parse lockfile YAML text or an already-loaded JS value into a validated document.
+ */
+declare function parseLockfile(input: string | object | null): LockfileDocument;
+//#endregion
+//#region src/modules/Lockfile/serialize.d.ts
+/**
+ * Serialize a lockfile document to YAML.
+ * - Always emits explicit `lockfile_version`
+ * - Forces `"2"` when any `source: registry` or git-semver fields present
+ * - Never demotes a loaded `"2"` → `"1"` (OpenAPM req-lk-002 monotonic)
+ * - Sorts dependencies by `(repo_url, virtual_path)`
+ * - Omits unset/null placeholders; preserves unknown / `x-*` bags
+ */
+declare function serializeLockfile(document: LockfileInput): string;
+//#endregion
+//#region src/modules/Lockfile/equivalence.d.ts
+/**
+ * Semantic equivalence ignoring `generated_at` / `apm_version` (req-lk-005).
+ */
+declare function isSemanticallyEquivalent(a: LockfileInput, b: LockfileInput): boolean;
+//#endregion
+//#region src/modules/Lockfile/treeSha256.d.ts
+type TreeSha256Violation = {
+  entry: string;
+  kind: "missing_field" | "missing_tree" | "mismatch";
+  expected?: string;
+  observed?: string;
+  message: string;
+};
+/**
+ * Compute OpenAPM canonical tree hash for a package root on disk.
+ * Returns envelope `sha256:<lowercase-hex>`.
+ */
+declare function computeCanonicalTreeSha256(rootDir: string): string;
+/** Compare two hash envelopes / bare hex for equality. */
+declare function treeSha256Equal(a: string, b: string): boolean;
+/**
+ * Format a violation message naming entry + expected/observed envelopes.
+ */
+declare function formatTreeSha256Violation(v: Omit<TreeSha256Violation, "message"> & {
+  message?: string;
+}): TreeSha256Violation;
+/** Git-sourced lock entry (not local-path / registry). */
+declare function isGitSourcedLockEntry(dep: LockedDependency): boolean;
+/**
+ * Locate materialized git package tree under `apm_modules` for a lock entry.
+ */
+declare function locateGitPackageTree(cwd: string, dep: LockedDependency): string | undefined;
+/**
+ * Collect tree_sha256 violations for git-sourced lock entries (audit / frozen).
+ * Fail-closed: missing field, missing on-disk tree, or hash mismatch.
+ */
+declare function collectTreeSha256Violations(args: {
+  cwd: string;
+  document: LockfileDocument;
+}): TreeSha256Violation[];
+//#endregion
+//#region src/modules/Resolver/constants.d.ts
+/** Default modules cache directory (APM wire parity). */
+declare const APM_MODULES_DIR = "apm_modules";
+/** OpenAPM / APM default max resolve depth (req-rs-006). */
+declare const MAX_RESOLVE_DEPTH = 50;
+/** Default parallel download concurrency (APM `--parallel-downloads` default). */
+declare const DEFAULT_PARALLEL_DOWNLOADS = 4;
+//#endregion
+//#region src/modules/Resolver/errors.d.ts
+type ResolverErrorCode = "RESOLVE_NEST_REFUSED" | "RESOLVE_DEPTH_EXCEEDED" | "RESOLVE_CYCLE" | "RESOLVE_EMPTY_INTERSECTION" | "RESOLVE_REGISTRY_DEFERRED" | "RESOLVE_NO_MATCHING_TAG" | "RESOLVE_FAILED" | "LOCAL_PATH_ESCAPES_PROJECT_ROOT" | "LOCAL_ROOT_TRACKED" | "DOWNLOAD_FAILED" | "CLASSIFY_INVALID";
+declare class ResolverError extends Error {
+  readonly code: ResolverErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: ResolverErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Resolver/types.d.ts
+/**
+ * Injectable ports for git remote / tag listing / download (fake-friendly for tests).
+ */
+type FakeTag = {
+  tag: string;
+  commit: string;
+  /**
+   * Positive annotated peel evidence (`refs/tags/…^{}` or injectable stub).
+   * Missing/false = lightweight / unknown — revision-pin path fail-closes.
+   */
+  annotated?: boolean;
+};
+type TagLister = {
+  listTags(repoUrl: string): Promise<FakeTag[]>;
+};
+type GitRemote = {
+  /** Resolve a literal ref (branch/tag/commit) to a 40-hex commit. */
+  resolveRef(repoUrl: string, ref: string): Promise<string>;
+};
+type DownloadArgs = {
+  repoUrl?: string;
+  path?: string;
+  commit?: string;
+  dest: string;
+  identity?: string;
+};
+type Downloader = {
+  download(args: DownloadArgs): Promise<void>;
+};
+type DependencyKind = "local" | "registry" | "git-semver" | "git-literal" | "marketplace";
+type ClassifiedDependency = {
+  kind: DependencyKind;
+  /** Original raw input preserved for diagnostics. */
+  raw: unknown;
+  path?: string;
+  git?: string;
+  ref?: string;
+  id?: string;
+  registry?: string;
+  alias?: string;
+  /** Manifest-level prerelease opt-in for git-semver. */
+  prerelease?: boolean;
+  /** Marketplace object/string form fields. */
+  pluginName?: string;
+  marketplaceName?: string;
+  versionSpec?: string;
+};
+type ResolvedNode = {
+  name: string;
+  identity: string;
+  kind: DependencyKind;
+  depth: number;
+  resolved_by: string;
+  /** Display / lock repo_url (host/path form without scheme when git). */
+  repo_url?: string;
+  path?: string;
+  resolved_commit?: string;
+  /** Pin identity for lock emit / outdated tip (literal ref or picked tag). */
+  resolved_ref?: string;
+  constraint?: string;
+  resolved_tag?: string;
+  resolved_at?: string;
+  version?: string;
+  /** Absolute path to materialized package tree (local source or modules cache). */
+  packageRoot?: string;
+  /** Artifact format is explicit; portable roots are never treated as apm.yml. */
+  artifactFormat?: "openapm" | "agent-plugin";
+  /** Registry lock fields (M10). */
+  source?: string;
+  resolved_url?: string;
+  resolved_hash?: string;
+  registry_base_url?: string;
+  registry_owner?: string;
+  registry_repo?: string;
+  /** Marketplace-origin provenance (concrete source retained). */
+  discovered_via?: string;
+  marketplace_plugin_name?: string;
+  source_url?: string;
+  source_digest?: string;
+};
+type ResolveGraphResult = {
+  nodes: ResolvedNode[];
+  /** Depth-1 visit order (declaration order among siblings). */
+  visitOrder: string[];
+  /**
+   * Lock-shaped dependency view (includes marketplace provenance).
+   * Convenience for callers / acceptance that inspect graph outcomes as lock rows.
+   */
+  lockfile?: {
+    dependencies: Array<Record<string, unknown>>;
+  };
+  document?: {
+    dependencies: Array<Record<string, unknown>>;
+  };
+};
+type ResolvePorts = {
+  gitRemote?: GitRemote;
+  tagLister?: TagLister;
+  downloader?: Downloader;
+};
+type ResolveDependencyGraphOptions = ResolvePorts & {
+  cwd?: string;
+  updateRefs?: boolean;
+  /**
+   * When set with `updateRefs`, only these package names (+ their subtrees)
+   * re-resolve; other direct pins stay identical (OpenAPM rs-012).
+   * Empty / omitted with updateRefs → full update (rs-011).
+   */
+  scope?: string[];
+  /** Alias for `scope` (CLI / update API). */
+  updatePackageNames?: string[];
+  maxDepth?: number;
+  /** When set, used for warm replay instead of loading from disk. */
+  existingLock?: {
+    dependencies?: Array<Record<string, unknown>>;
+  } | null;
+  /**
+   * Plan-only resolve: do not create `apm_modules` or download local path deps.
+   * Local packages are read from source paths. Git still materializes when needed
+   * to read child manifests (residual pl-002 gap for cold git trees).
+   */
+  skipDownload?: boolean;
+  /** Alias for `skipDownload` (plan → gate → download). */
+  planOnly?: boolean;
+  /** Opt-in experimental registries (also via BAPM_EXPERIMENTAL_REGISTRIES=1). */
+  experimentalRegistries?: boolean;
+  /** Override registry base URL (tests). */
+  registryBaseUrl?: string;
+  /** Mirror base URL for rs-009 replay (tests / install). */
+  mirrorUrl?: string;
+  /** Override `~/.bapm` config root for marketplace registry/cache. */
+  marketplaceConfigDir?: string;
+  /** Alias for marketplaceConfigDir. */
+  configDir?: string;
+};
+type DownloadPackageSpec = {
+  repoUrl?: string;
+  path?: string;
+  commit?: string;
+  identity?: string;
+  name?: string;
+};
+type DownloadPackagesOptions = ResolvePorts & {
+  cwd?: string;
+  packages: DownloadPackageSpec[];
+  parallelDownloads?: number;
+};
+type ResolveAndLockOptions = ResolvePorts & {
+  cwd?: string;
+  updateRefs?: boolean;
+  /** Package scope for update (rs-012); see ResolveDependencyGraphOptions.scope. */
+  scope?: string[];
+  updatePackageNames?: string[];
+  /**
+   * When true (default on updateRefs), purge git-semver modules install paths
+   * for scoped/full update targets before re-download (lk-010).
+   */
+  purgeInstallPaths?: boolean;
+  parallelDownloads?: number;
+  maxDepth?: number;
+  verbose?: boolean;
+  /** Explicit policy file path for install/lock gate. */
+  policyPath?: string;
+  /** Alias for `policyPath`. */
+  policy?: string;
+  /** Skip policy discovery + checks. */
+  noPolicy?: boolean;
+  /** Override ordered policy discovery providers. */
+  policyProviders?: string[];
+  providers?: string[];
+  listGitRemotes?: (cwd?: string) => Array<{
+    name: string;
+    url: string;
+  }>;
+  remotes?: Array<{
+    name: string;
+    url: string;
+  }>;
+  fetchPolicyUrl?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  httpGet?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  fetchAncestor?: (ref: string, context: {
+    leafHostClass: string;
+    chain: string[];
+  }) => unknown;
+  defaultFetchFailure?: "off" | "warn" | "block";
+  implementationDefaultHost?: string;
+  experimentalRegistries?: boolean;
+  registryBaseUrl?: string;
+  mirrorUrl?: string;
+  marketplaceConfigDir?: string;
+  configDir?: string;
+};
+type ResolveAndLockResult = {
+  document: Record<string, unknown>;
+  lockPath: string;
+  nodes: ResolvedNode[];
+  /** Policy gate diagnostics when policy applied (M8). */
+  policyDiagnostics?: unknown[];
+};
+//#endregion
+//#region src/modules/Resolver/classify.d.ts
+/**
+ * Classify a dependency declaration (OpenAPM kind precedence:
+ * local → registry → git-semver → git-literal; marketplace non-normative).
+ * Bapm `local` discriminator expands to the effective path before kind: local.
+ */
+declare function classifyDependencyRef(input: unknown): ClassifiedDependency;
+//#endregion
+//#region src/modules/Resolver/resolveGraph.d.ts
+/**
+ * BFS transitive resolve with OpenAPM intersection-pick diamonds (not APM first-wins).
+ */
+declare function resolveDependencyGraph(options?: ResolveDependencyGraphOptions): Promise<ResolveGraphResult>;
+//#endregion
+//#region src/modules/Resolver/download.d.ts
+/**
+ * Materialize packages into `<cwd>/apm_modules/` via Downloader port.
+ */
+declare function downloadPackages(options: DownloadPackagesOptions): Promise<string[]>;
+//#endregion
+//#region src/modules/Policy/errors.d.ts
+/** Typed diagnostics for policy discovery / YAML load / validate / gate. */
+type PolicyErrorCode = "POLICY_NOT_FOUND" | "POLICY_DUAL_CONFLICT" | "POLICY_MISSING_FILE" | "POLICY_YAML_PARSE" | "POLICY_YAML_SAFE_SUBSET" | "POLICY_VALIDATION" | "POLICY_VIOLATION" | "POLICY_EXTENDS_CYCLE" | "POLICY_EXTENDS_DEPTH" | "POLICY_EXTENDS_FETCH" | "POLICY_HOST_CLASS_PIN" | "POLICY_REMOTE_AMBIGUOUS" | "POLICY_FETCH_FAILURE";
+declare class PolicyError extends Error {
+  readonly code: PolicyErrorCode;
+  readonly path?: string;
+  readonly details?: Record<string, unknown>;
+  constructor(code: PolicyErrorCode, message: string, options?: {
+    path?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+type PolicyWarning = {
+  code: string;
+  message: string;
+  path?: string;
+};
+//#endregion
+//#region src/modules/Policy/types.d.ts
+type PolicyEnforcement = "off" | "warn" | "block";
+type PolicyDependencies = {
+  /** Tri-state: omit/null → unset; [] → explicit empty; [...] → populated. */
+  allow?: string[] | null;
+  deny?: string[] | null;
+  require?: string[] | null;
+  max_depth?: number;
+  require_pinned_constraint?: boolean;
+};
+/** Org-policy executables floor (sc-011): deny_all + deny list only for claim. */
+type PolicyExecutables = {
+  deny_all?: boolean;
+  deny?: string[];
+};
+type PolicyDocument = {
+  name: string;
+  enforcement: PolicyEnforcement;
+  fetch_failure: PolicyEnforcement;
+  dependencies?: PolicyDependencies;
+  executables?: PolicyExecutables;
+  /** Extension keys `x-*` and other retained top-level fields. */
+  [key: string]: unknown;
+};
+type DiscoverPolicyOptions = {
+  cwd?: string;
+  /** Explicit path wins over dual-read sibling search. */
+  path?: string;
+};
+type DiscoveredPolicy = {
+  path: string;
+  filename: string;
+  absent?: false;
+  found?: true;
+} | {
+  absent: true;
+  found?: false;
+  path?: null;
+};
+type LoadPolicyOptions = {
+  cwd?: string;
+  path?: string;
+};
+type LoadPolicyResult = {
+  document: PolicyDocument;
+  policy?: PolicyDocument;
+  sourcePath: string;
+  sourceFilename: string;
+  warnings: PolicyWarning[];
+};
+type ParsePolicyResult = {
+  document: PolicyDocument;
+  policy?: PolicyDocument;
+  warnings: PolicyWarning[];
+};
+type PolicyCandidate = {
+  id?: string;
+  name?: string;
+  ref?: string;
+  constraint?: string;
+  depth?: number;
+  direct?: boolean;
+  kind?: string;
+  path?: string;
+  source?: string;
+};
+type PolicyDependencyInput = string | {
+  name?: string;
+  id?: string;
+  ref?: string;
+  constraint?: string;
+  direct?: boolean;
+  depth?: number;
+  path?: string;
+  source?: string;
+};
+type EvaluatePolicyOptions = {
+  policy: PolicyDocument;
+  candidates?: PolicyCandidate[];
+  dependencies?: PolicyDependencyInput[];
+  graphDepth?: number;
+  maxDepthObserved?: number;
+};
+type PolicyViolation = {
+  code: string;
+  message: string;
+  identity?: string;
+  rule?: string;
+};
+type EvaluatePolicyResult = {
+  ok: boolean;
+  blocking: boolean;
+  blocked?: boolean;
+  outcome: "off" | "warn" | "block" | "pass";
+  enforcementOutcome?: "off" | "warn" | "block" | "pass";
+  mode?: PolicyEnforcement;
+  violations: PolicyViolation[];
+  warnings: PolicyWarning[];
+  findings?: PolicyViolation[];
+  errors?: PolicyViolation[];
+};
+type PolicyGateOptions = {
+  cwd?: string;
+  /** Explicit policy file path (`--policy`). */
+  policyPath?: string;
+  /** Alias accepted by acceptance helpers. */
+  policy?: string;
+  /** Skip discovery + checks (`--no-policy`). */
+  noPolicy?: boolean;
+  candidates?: PolicyCandidate[];
+  dependencies?: PolicyDependencyInput[];
+  graphDepth?: number;
+  maxDepthObserved?: number;
+};
+type PolicyGateResult = {
+  skipped: boolean;
+  absent: boolean;
+  blocking: boolean;
+  result?: EvaluatePolicyResult;
+  document?: PolicyDocument;
+  sourcePath?: string;
+  diagnostics: unknown[];
+};
+//#endregion
+//#region src/modules/Policy/remotes.d.ts
+/**
+ * pl-012 project remote selection for policy discovery.
+ */
+type GitRemoteEntry = {
+  name: string;
+  url: string;
+};
+type SelectProjectRemoteOptions = {
+  cwd?: string;
+  /** Injected remotes (preferred when provided). */
+  remotes?: GitRemoteEntry[];
+  /** Injectable list reader (acceptance / tests). */
+  listGitRemotes?: (cwd?: string) => GitRemoteEntry[];
+};
+type SelectedProjectRemote = (GitRemoteEntry & {
+  remote?: GitRemoteEntry;
+  skipped?: false;
+  absent?: false;
+}) | {
+  absent: true;
+  skipped: true;
+  remote?: null;
+} | null;
+/**
+ * Prefer `origin`; else single remote; else fail closed naming candidates; else skip.
+ */
+declare function selectProjectRemote(options?: SelectProjectRemoteOptions): SelectedProjectRemote;
+/** Alias names accepted by acceptance helpers. */
+declare const selectGitRemoteForPolicy: typeof selectProjectRemote;
+declare const resolveProjectRemote: typeof selectProjectRemote;
+/**
+ * Production git remote reader (`git remote -v`). Dedupes fetch URLs by name.
+ */
+declare function listGitRemotes(cwd?: string): GitRemoteEntry[];
+//#endregion
+//#region src/modules/Policy/resolve.d.ts
+/** Max ancestor hops from leaf (OpenAPM pl-003). */
+declare const POLICY_EXTENDS_MAX_DEPTH = 5;
+type FetchAncestorResult = {
+  document?: PolicyDocument | Record<string, unknown>;
+  policy?: PolicyDocument | Record<string, unknown>;
+  source?: string;
+  url?: string;
+  hostClass?: string;
+  path?: string;
+  text?: string;
+};
+type FetchAncestor = (ref: string, context: {
+  leafHostClass: string;
+  chain: string[];
+}) => FetchAncestorResult | PolicyDocument | Record<string, unknown>;
+type ResolvePolicyChainOptions = {
+  cwd?: string;
+  path?: string;
+  leafPath?: string;
+  /** Pre-loaded leaf YAML text. */
+  leafYaml?: string;
+  /** Pre-parsed leaf document. */
+  leaf?: PolicyDocument | Record<string, unknown>;
+  document?: PolicyDocument | Record<string, unknown>;
+  /** Pin class for the leaf (optional; derived from leafHostClass / remotes / local). */
+  leafHostClass?: string;
+  /** Injectable ancestor fetcher for owner/repo / URL refs. */
+  fetchAncestor?: FetchAncestor;
+  /** Optional HTTP helper used when fetchAncestor is absent. */
+  fetchPolicyUrl?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  httpGet?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+};
+type ResolvePolicyChainResult = {
+  document: PolicyDocument;
+  policy: PolicyDocument;
+  effective: PolicyDocument;
+  chain: string[];
+  sourcePath?: string;
+  warnings: unknown[];
+};
+/**
+ * Resolve `extends:` into one effective policy document.
+ */
+declare function resolvePolicyChain(options?: ResolvePolicyChainOptions): ResolvePolicyChainResult;
+/** Alias names accepted by acceptance helpers. */
+declare const resolveExtends: typeof resolvePolicyChain;
+declare const resolvePolicyExtends: typeof resolvePolicyChain;
+declare const mergePolicyChain: typeof resolvePolicyChain;
+//#endregion
+//#region src/modules/Policy/load.d.ts
+type LoadPolicyExtendedOptions = LoadPolicyOptions & {
+  /** Skip extends resolve (leaf only). */
+  skipExtends?: boolean;
+  providers?: string[];
+  policyProviders?: string[];
+  listGitRemotes?: (cwd?: string) => GitRemoteEntry[];
+  remotes?: GitRemoteEntry[];
+  fetchAncestor?: FetchAncestor;
+  fetchPolicyUrl?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  httpGet?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  defaultFetchFailure?: "off" | "warn" | "block";
+  implementationDefaultHost?: string;
+  leafHostClass?: string;
+};
+/**
+ * Discover → read → parse → resolve extends → effective document.
+ * Explicit missing path fails closed. Provider-based discovery when no path.
+ */
+declare function loadPolicy(options?: LoadPolicyExtendedOptions): LoadPolicyResult;
+//#endregion
+//#region src/modules/Policy/status.d.ts
+type PolicyStatusOutcome = "found" | "absent" | "disabled" | "error";
+type PolicyStatusRuleCounts = {
+  allow: number;
+  deny: number;
+  require: number;
+  max_depth: number;
+  require_pinned_constraint: number;
+  /** Nested form accepted by flexible readers. */
+  dependencies?: {
+    allow: number;
+    deny: number;
+    require: number;
+    max_depth: number;
+    require_pinned_constraint: number;
+  };
+};
+type PolicyStatusReport = {
+  outcome: PolicyStatusOutcome;
+  source: string | null;
+  provider: string;
+  enforcement: PolicyEnforcement | null;
+  extends_chain: string[];
+  rule_counts: PolicyStatusRuleCounts;
+  warnings: unknown[];
+  diagnostics: unknown[];
+};
+type PolicyStatusOptions = {
+  cwd?: string;
+  policyPath?: string;
+  policy?: string;
+  noPolicy?: boolean;
+  providers?: string[];
+  policyProviders?: string[];
+  listGitRemotes?: (cwd?: string) => GitRemoteEntry[];
+  remotes?: GitRemoteEntry[];
+  fetchAncestor?: FetchAncestor;
+  fetchPolicyUrl?: LoadPolicyExtendedOptions["fetchPolicyUrl"];
+  httpGet?: LoadPolicyExtendedOptions["httpGet"];
+  defaultFetchFailure?: "off" | "warn" | "block";
+  implementationDefaultHost?: string;
+  leafHostClass?: string;
+};
+/**
+ * Compute a structured policy status report without mutating the project.
+ * Soft-maps dual-conflict / fetch / schema failures to `outcome: error` (no throw).
+ */
+declare function runPolicyStatus(options?: PolicyStatusOptions): PolicyStatusReport;
+//#endregion
+//#region src/modules/Policy/constants.d.ts
+/** Local dual-read policy filenames (discovery only; schema identical). */
+declare const APM_POLICY_FILE = "apm-policy.yml";
+declare const BAPM_POLICY_FILE = "bapm-policy.yml";
+/**
+ * Ordered discovery provider ids (pl-011).
+ * Default: local dual-read first, then minimal remote `github-owner-dotgithub` (design D2).
+ */
+declare const POLICY_PROVIDER_LOCAL: "local";
+declare const POLICY_PROVIDER_GITHUB_OWNER_DOTGITHUB: "github-owner-dotgithub";
+/**
+ * Ordered discovery providers (pl-001/011).
+ * Local dual-read first; remote github-owner-dotgithub when local is absent.
+ */
+declare const DEFAULT_POLICY_PROVIDERS: readonly ["local", "github-owner-dotgithub"];
+/** Alias export names accepted by acceptance helpers. */
+declare const POLICY_DISCOVERY_PROVIDERS: readonly ["local", "github-owner-dotgithub"];
+declare const defaultPolicyProviders: readonly ["local", "github-owner-dotgithub"];
+//#endregion
+//#region src/modules/Policy/discover.d.ts
+/**
+ * Resolve which local policy file to load.
+ * Explicit `path` wins; otherwise exactly one of apm-policy.yml / bapm-policy.yml at cwd.
+ * Neither → absent (not an error). Does not walk parent directories.
+ */
+declare function discoverPolicyPath(options?: DiscoverPolicyOptions): DiscoveredPolicy;
+/** Alias accepted by acceptance helpers. */
+declare const discoverLocalPolicyPath: typeof discoverPolicyPath;
+//#endregion
+//#region src/modules/Policy/providers.d.ts
+type DiscoverPolicyWithProvidersOptions = {
+  cwd?: string;
+  /** Override provider order (else DEFAULT_POLICY_PROVIDERS or discovery:). */
+  providers?: string[];
+  policyProviders?: string[];
+  /** Explicit local path wins. */
+  path?: string;
+  listGitRemotes?: (cwd?: string) => GitRemoteEntry[];
+  remotes?: GitRemoteEntry[];
+  implementationDefaultHost?: string;
+  fetchPolicyUrl?: (url: string) => HttpFetchResult;
+  httpGet?: (url: string) => HttpFetchResult;
+  /** When remote fetch fails before a document exists. */
+  defaultFetchFailure?: "off" | "warn" | "block";
+};
+type HttpFetchResult = {
+  ok?: boolean;
+  text?: string;
+  body?: string;
+  status?: number;
+  url?: string;
+};
+type DiscoverPolicyWithProvidersResult = {
+  absent?: false;
+  found: true;
+  path?: string;
+  filename?: string;
+  url?: string;
+  provider: string;
+  document?: PolicyDocument;
+  policy?: PolicyDocument;
+  text?: string;
+  source?: string;
+} | {
+  absent: true;
+  found?: false;
+  path?: null;
+  providers?: string[];
+  skipped?: boolean;
+};
+/**
+ * Run ordered discovery providers until one yields a policy.
+ */
+declare function discoverPolicyWithProviders(options?: DiscoverPolicyWithProvidersOptions): DiscoverPolicyWithProvidersResult;
+/** Alias names accepted by acceptance helpers. */
+declare const runPolicyDiscovery: typeof discoverPolicyWithProviders;
+declare const discoverPolicyProviders: typeof discoverPolicyWithProviders;
+//#endregion
+//#region src/modules/Policy/parse.d.ts
+/**
+ * Validate a pre-parsed JS value as an OpenAPM-shaped policy document.
+ * Retains unknown top-level (with warnings) and `x-*` (silent) keys.
+ */
+declare function parsePolicyDocument(input: unknown): ParsePolicyResult;
+/** Back-compat / acceptance entry for already-loaded JS objects. */
+declare function parsePolicy(input: unknown): ParsePolicyResult;
+//#endregion
+//#region src/modules/Policy/merge.d.ts
+type MergePoliciesResult = {
+  document: PolicyDocument;
+  policy: PolicyDocument;
+  effective: PolicyDocument;
+};
+/**
+ * Merge parent into child (child is nearer the leaf). Returns effective document.
+ */
+declare function mergePolicies(parent: unknown, child: unknown): MergePoliciesResult;
+/** Alias names accepted by acceptance helpers. */
+declare const mergePolicyDocuments: typeof mergePolicies;
+declare const mergePolicy: typeof mergePolicies;
+//#endregion
+//#region src/modules/Policy/hostClass.d.ts
+type HostClassInput = string | {
+  url?: string;
+  host?: string;
+  hostname?: string;
+};
+/** Implementation-default host for `github-owner-dotgithub` (design D1). */
+declare const IMPLEMENTATION_DEFAULT_HOST = "github.com";
+/**
+ * Derive host class from a URL / hostname using PSL eTLD+1 (unified with Auth).
+ */
+declare function hostClassOf(input: HostClassInput): string;
+/** Alias accepted by acceptance helpers. */
+declare const policyHostClass: typeof hostClassOf;
+declare const hostClassForPolicy: typeof hostClassOf;
+declare const resolveHostClass: typeof hostClassOf;
+//#endregion
+//#region src/modules/Policy/evaluate.d.ts
+/**
+ * Evaluate policy rules against install candidates.
+ * Deny wins over allow; enforcement off|warn|block maps to gate outcome.
+ */
+declare function evaluateInstallPolicy(options: EvaluatePolicyOptions): EvaluatePolicyResult;
+/** Aliases accepted by acceptance helpers. */
+declare const evaluatePolicy: typeof evaluateInstallPolicy;
+declare const evaluatePolicyRules: typeof evaluateInstallPolicy;
+//#endregion
+//#region src/modules/Policy/escape.d.ts
+/**
+ * Escape hatch: skip discovery + checks (not a discovery provider).
+ * Primary: BAPM_POLICY_DISABLE=1; also honor APM_POLICY_DISABLE=1.
+ */
+declare function isPolicyDisabled(options?: {
+  noPolicy?: boolean;
+}): boolean;
+//#endregion
+//#region src/modules/Policy/gate.d.ts
+type PolicyGateExtendedOptions = PolicyGateOptions & {
+  providers?: string[];
+  policyProviders?: string[];
+  listGitRemotes?: (cwd?: string) => GitRemoteEntry[];
+  remotes?: GitRemoteEntry[];
+  fetchAncestor?: FetchAncestor;
+  fetchPolicyUrl?: LoadPolicyExtendedOptions["fetchPolicyUrl"];
+  httpGet?: LoadPolicyExtendedOptions["httpGet"];
+  defaultFetchFailure?: "off" | "warn" | "block";
+  implementationDefaultHost?: string;
+  leafHostClass?: string;
+};
+/**
+ * Discover (+ remote providers) → resolve/merge extends → evaluate install policy gate.
+ * Dual-conflict / missing explicit file / fetch_failure:block fail closed.
+ * Absent policy → ungated (skipped). Escape via noPolicy / env.
+ */
+declare function runPolicyGate(options?: PolicyGateExtendedOptions): PolicyGateResult;
+/**
+ * Assert gate is not blocking; throw PolicyError on block violations.
+ */
+declare function assertPolicyGateAllows(options?: PolicyGateExtendedOptions): PolicyGateResult;
+//#endregion
+//#region src/modules/Policy/redact.d.ts
+/**
+ * Redact credential-bearing URLs / refs before status display.
+ * Drops userinfo and query string; also scrub plaintext secrets that survive path.resolve.
+ */
+/**
+ * Scrub a single source / extends ref for human + JSON report fields.
+ */
+declare function redactPolicyRef(ref: string): string;
+//#endregion
+//#region src/modules/Resolver/resolveAndLock.d.ts
+/**
+ * Orchestrate: load manifest → resolve plan → policy gate → download → write lock.
+ */
+declare function resolveAndLock(options?: ResolveAndLockOptions): Promise<ResolveAndLockResult & {
+  policyDiagnostics?: unknown[];
+}>;
+declare function materializeRegistryNodes(nodes: ResolvedNode[], options: {
+  cwd: string;
+  mirrorUrl?: string;
+  registryBaseUrl?: string;
+}): Promise<void>;
+//#endregion
+//#region src/modules/Resolver/purge.d.ts
+type PurgeInstallPathArgs = {
+  cwd: string;
+  /** Package names / identity basenames to purge. */
+  packageNames: string[];
+  /** Optional lock deps to also purge by repo identity cache dirs. */
+  lockDeps?: Array<Record<string, unknown>>;
+};
+/**
+ * Remove modules dirs for named packages (and matching identity cache trees)
+ * so download materializes again even when the resolved tag is unchanged.
+ */
+declare function purgeModulesInstallPaths(args: PurgeInstallPathArgs): string[];
+//#endregion
+//#region src/modules/Resolver/identity.d.ts
+/**
+ * Minimum-safe repo identity for resolve/cache (req-rs-016).
+ * - Host case folded to lowercase
+ * - Trailing `.git` stripped
+ * - Path case preserved (example/REPO ≠ example/repo)
+ * - Cache keys MUST NOT isolate solely by ref
+ */
+declare function normalizeRepoIdentity(repoUrl: string): string;
+/** Lockfile / display repo_url: host/path without scheme. */
+declare function toLockRepoUrl(repoUrl: string): string;
+/**
+ * Safe directory segment for modules cache keyed by identity (not by ref alone).
+ */
+declare function identityToCacheDir(identity: string): string;
+//#endregion
+//#region src/modules/Resolver/localSource.d.ts
+/**
+ * Bapm-only `local` source discriminator helpers (expand default / custom path).
+ */
+/** Default package root when `local` has no custom path. */
+declare const DEFAULT_LOCAL_ROOT = ".agents/local";
+/**
+ * Expand a parsed `local` value to the effective project-relative path.
+ * `true` | `null` | `""` | `undefined` → `.agents/local`; non-empty string → as-is.
+ */
+declare function effectiveLocalPath(local: unknown): string;
+/** Normalize a relative local root to a stable rooted gitignore pattern. */
+declare function localRootGitignorePattern(effectivePath: string): string;
+//#endregion
+//#region src/modules/Resolver/ensureLocalUntracked.d.ts
+type EnsureLocalRootUntrackedOptions = {
+  projectRoot: string;
+  /** Effective local path as declared / expanded (e.g. `.agents/local`, `./alt-local`). */
+  originalPath: string;
+};
+/**
+ * Collect effective paths for every root `local` discriminator in the manifest.
+ * Plain OpenAPM `path:` entries are ignored.
+ */
+declare function collectLocalSourcePaths(manifest: BapmManifest): string[];
+/**
+ * For every `local` source on the root manifest, ensure the effective root is
+ * covered by project `.gitignore` and (when `.git` exists) is not tracked.
+ */
+declare function ensureLocalSourcesUntracked(options: {
+  projectRoot: string;
+  manifest: BapmManifest;
+}): void;
+/**
+ * Ensure one effective local root is ignored; fail closed if git tracks files under it.
+ */
+declare function ensureLocalRootUntracked(options: EnsureLocalRootUntrackedOptions): void;
+//#endregion
+//#region src/modules/Resolver/semver.d.ts
+/**
+ * Pick highest satisfying tag among candidates.
+ * Prereleases excluded unless range opts in (contains prerelease id) or includePrerelease.
+ * Build-metadata ties: highest ASCII full tag string (req-rs-014).
+ */
+declare function pickHighestSatisfyingTag(tags: string[], range: string, options?: {
+  includePrerelease?: boolean;
+}): string | null;
+/**
+ * Intersect multiple ranges; return highest version among candidate tags in ∩,
+ * or null if empty.
+ */
+declare function pickHighestInIntersection(tags: string[], ranges: string[], options?: {
+  includePrerelease?: boolean;
+}): string | null;
+/** Which range is "tightest" among a set (prefer narrower / more specific). */
+declare function pickTightestRange(ranges: string[]): string;
+//#endregion
+//#region src/modules/Resolver/defaults.d.ts
+/**
+ * Default TagLister via `git ls-remote --tags --refs`.
+ * Omits peeled `^{}` lines — used by resolve / constraint paths (stable).
+ */
+declare function createDefaultTagLister(): TagLister;
+/**
+ * Peel-aware TagLister for Outdated full-SHA revision-pin path.
+ * `git ls-remote --tags` (no `--refs`); pairs `refs/tags/X^{}` → annotated.
+ */
+declare function createPeelAwareTagLister(): TagLister;
+/** Default GitRemote via `git ls-remote`. */
+declare function createDefaultGitRemote(): GitRemote;
+/** Default Downloader: local copy or shallow git clone into apm_modules. */
+declare function createDefaultDownloader(): Downloader;
+//#endregion
+//#region src/modules/Primitives/types.d.ts
+type PrimitiveSource = "local" | `dependency:${string}`;
+type PrimitiveType = string;
+type AttributedPrimitive = {
+  name: string;
+  type: PrimitiveType;
+  source: PrimitiveSource;
+  path: string;
+  packageName?: string;
+  content?: string;
+  /**
+   * Complete portable skill directory. Present only for Agent Plugins skills so
+   * targets can import auxiliary scripts, references, and assets as one unit.
+   */
+  skillDirectory?: string;
+  pluginRoot?: string;
+  format?: "agent-plugin";
+  [key: string]: unknown;
+};
+type DiscoverPrimitivesOptions = {
+  cwd?: string;
+  /** Modules root; defaults to `<cwd>/apm_modules`. */
+  modulesDir?: string;
+  /** Declaration order of dependency package names (pr-003). */
+  declarationOrder?: string[];
+};
+type PrimitiveConflictDiagnostic = {
+  code: string;
+  message: string;
+  name: string;
+  type: string;
+  winnerSource: string;
+  loserSource: string;
+};
+type ResolvePrimitiveConflictsOptions = {
+  primitives: AttributedPrimitive[];
+  cwd?: string;
+  declarationOrder?: string[];
+};
+type ResolvePrimitiveConflictsResult = {
+  primitives: AttributedPrimitive[];
+  diagnostics: PrimitiveConflictDiagnostic[];
+};
+//#endregion
+//#region src/modules/Primitives/errors.d.ts
+type PrimitivesErrorCode = "PRIMITIVES_DISCOVER_FAILED" | "PRIMITIVES_CONFLICT";
+declare class PrimitivesError extends Error {
+  readonly code: PrimitivesErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: PrimitivesErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Primitives/discover.d.ts
+/**
+ * Discover attributed primitives under the project and dependency modules trees.
+ */
+declare function discoverPrimitives(options?: DiscoverPrimitivesOptions): AttributedPrimitive[];
+//#endregion
+//#region src/modules/Primitives/conflicts.d.ts
+/**
+ * Resolve name+type conflicts: local wins over deps (pr-002);
+ * among deps, first-declared wins (pr-003).
+ */
+declare function resolvePrimitiveConflicts(options: ResolvePrimitiveConflictsOptions): ResolvePrimitiveConflictsResult;
+/** Alias for callers that prefer a shorter name. */
+declare const resolveConflicts: typeof resolvePrimitiveConflicts;
+//#endregion
+//#region src/modules/AgentPlugins/types.d.ts
+declare const AGENT_PLUGIN_MANIFEST_SCHEMA_V1 = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+type AgentPluginAuthor = {
+  name?: string;
+  email?: string;
+  url?: string;
+};
+/** Schema-compatible portable Agent Plugins v1 manifest. */
+type AgentPluginManifest = {
+  $schema: typeof AGENT_PLUGIN_MANIFEST_SCHEMA_V1;
+  name: string;
+  version?: string;
+  description?: string;
+  author?: AgentPluginAuthor;
+  homepage?: string;
+  repository?: string;
+  license?: string;
+  keywords?: string[];
+  /** Declared command file paths relative to the plugin root. */
+  commands?: string[];
+  /** Declared hook JSON paths relative to the plugin root. */
+  hooks?: string[];
+  extensions?: Record<string, Record<string, unknown>>;
+};
+type AgentPluginDiagnostic = {
+  code: string;
+  message: string;
+  path?: string;
+  severity: "warning" | "error";
+};
+type LoadAgentPluginManifestOptions = {
+  /** Absolute or relative plugin package root. */
+  root: string;
+};
+/** Input accepted by the portable v1 producer. */
+type CreateAgentPluginManifestOptions = {
+  name: string;
+  version?: string;
+  description?: string;
+  author?: AgentPluginAuthor;
+  homepage?: string;
+  repository?: string;
+  license?: string;
+  keywords?: string[];
+  extensions?: Record<string, Record<string, unknown>>;
+};
+type WriteAgentPluginManifestOptions = CreateAgentPluginManifestOptions & {
+  /** Plugin package root. Created by the writer when absent. */
+  root?: string;
+  /** Explicit output path. Must be `<root>/plugin.json` when root is supplied. */
+  path?: string;
+};
+type WrittenAgentPluginManifest = {
+  root: string;
+  manifestPath: string;
+  manifest: AgentPluginManifest;
+};
+type LoadedAgentPluginManifest = {
+  root: string;
+  manifestPath: string;
+  manifest: AgentPluginManifest;
+  diagnostics: AgentPluginDiagnostic[];
+};
+type AgentPluginSkill = {
+  /** Immediate directory name below `skills/`. */
+  name: string;
+  /** Realpath of the complete skill directory, safe to import as a directory. */
+  directory: string;
+  skillPath: string;
+};
+type DiscoverAgentPluginSkillsOptions = LoadAgentPluginManifestOptions & {
+  packageName?: string;
+};
+type DiscoverAgentPluginSkillsResult = LoadedAgentPluginManifest & {
+  skills: AgentPluginSkill[];
+};
+/** Declared command or hook file under a portable plugin root. */
+type AgentPluginDeclaredPath = {
+  /** Primitive name derived from the file stem. */
+  name: string;
+  type: "command" | "hook";
+  /** Realpath of the declared file within the plugin root. */
+  path: string;
+  /** Original declared relative path from plugin.json. */
+  declaredPath: string;
+};
+type DiscoverAgentPluginDeclaredPathsResult = LoadedAgentPluginManifest & {
+  commands: AgentPluginDeclaredPath[];
+  hooks: AgentPluginDeclaredPath[];
+};
+type AgentPluginMcpServer = {
+  name: string;
+  transport: "stdio" | "streamable-http" | "sse";
+  command?: string;
+  args?: string[];
+  url?: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  /** Signals to targets that this must be adapted, rather than passed through. */
+  format: "agent-plugin";
+};
+type DiscoverAgentPluginMcpOptions = LoadAgentPluginManifestOptions & {
+  /**
+   * Directory owned by bapm for this installed plugin. It is never taken from
+   * package configuration and is the only expansion target for PLUGIN_DATA.
+   */
+  dataRoot: string;
+};
+type DiscoverAgentPluginMcpResult = LoadedAgentPluginManifest & {
+  servers: AgentPluginMcpServer[];
+};
+//#endregion
+//#region src/modules/AgentPlugins/errors.d.ts
+type AgentPluginsErrorCode = "AGENT_PLUGIN_ROOT_INVALID" | "AGENT_PLUGIN_MANIFEST_INVALID" | "AGENT_PLUGIN_DECLARED_PATH_INVALID";
+declare class AgentPluginsError extends Error {
+  readonly code: AgentPluginsErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: AgentPluginsErrorCode, message: string, details?: Record<string, unknown>);
+}
+//#endregion
+//#region src/modules/AgentPlugins/load.d.ts
+/**
+ * Load the portable v1 manifest from exactly `<root>/plugin.json`.
+ * This is intentionally offline: `$schema` selects this local validator only.
+ */
+declare function loadAgentPluginManifest(options: LoadAgentPluginManifestOptions): LoadedAgentPluginManifest;
+declare function validateAgentPluginManifest(value: unknown, manifestPath?: string): {
+  manifest: AgentPluginManifest;
+  diagnostics: AgentPluginDiagnostic[];
+};
+//#endregion
+//#region src/modules/AgentPlugins/discover.d.ts
+/**
+ * Discover only immediate `skills/<name>/SKILL.md` entries and return complete,
+ * containment-checked directories for portable import.
+ */
+declare function discoverAgentPluginSkills(options: DiscoverAgentPluginSkillsOptions): DiscoverAgentPluginSkillsResult;
+//#endregion
+//#region src/modules/AgentPlugins/declaredPaths.d.ts
+/**
+ * Resolve `plugin.json` `commands` / `hooks` path lists under the plugin root.
+ * Missing or escaping declared paths fail closed (requirements, not hints).
+ */
+declare function discoverAgentPluginDeclaredPaths(options: DiscoverAgentPluginSkillsOptions): DiscoverAgentPluginDeclaredPathsResult;
+//#endregion
+//#region src/modules/AgentPlugins/mcp.d.ts
+/** Parse only `<plugin root>/mcp.json`; a bad file never invalidates skills. */
+declare function discoverAgentPluginMcp(options: DiscoverAgentPluginMcpOptions): DiscoverAgentPluginMcpResult;
+//#endregion
+//#region src/modules/AgentPlugins/write.d.ts
+/**
+ * Build the canonical portable v1 manifest. This is deliberately independent
+ * from Manifest/pluginJson.ts: APM producer metadata has different semantics.
+ */
+declare function createAgentPluginManifest(options: CreateAgentPluginManifestOptions): AgentPluginManifest;
+declare function serializeAgentPluginManifest(manifest: AgentPluginManifest): string;
+/**
+ * Validate before writing a portable root manifest. The output is always a
+ * regular `plugin.json`; it never creates an APM `bapm.yml` dependency contract.
+ */
+declare function writeAgentPluginManifest(options: WriteAgentPluginManifestOptions): WrittenAgentPluginManifest;
+//#endregion
+//#region src/modules/Install/types.d.ts
+type InstallOnlyMode = "apm" | "mcp";
+type RunInstallOptions = {
+  cwd?: string;
+  frozen?: boolean;
+  /** Rejected when combined with frozen. */
+  update?: boolean;
+  updateRefs?: boolean;
+  /**
+   * Preview-only install: no durable project writes (manifest/lock/modules/harness),
+   * no target materialize / configureMcp. Never forwarded to targets.
+   */
+  dryRun?: boolean;
+  /**
+   * Accept overwrite / future security-gate bypass. MUST NOT refresh refs,
+   * bypass frozen, or disable policy. Distinct from `forcedTarget`.
+   */
+  force?: boolean;
+  /** Dual-consent CLI half for direct `http://` dependencies. */
+  allowInsecure?: boolean;
+  /** Repeatable host allowlist for transitive `http://` dependencies (FQDN). */
+  allowInsecureHosts?: string[];
+  /**
+   * When set with `packageRefs`, write under `devDependencies.apm` instead of
+   * `dependencies.apm`. Without positional refs, no-op.
+   */
+  dev?: boolean;
+  /**
+   * Install mode: `apm` skips MCP configure; `mcp` skips APM package
+   * download/materialize. Omit = both sides.
+   */
+  only?: InstallOnlyMode;
+  /**
+   * Positional package refs to add under `dependencies.apm` before install
+   * (non-zip). Mutually exclusive with `archivePath`.
+   */
+  packageRefs?: string[];
+  /**
+   * Skip MCP configure for listed target/runtime ids (e.g. `cursor`).
+   * Does not skip package materialize. Alias: `exclude`.
+   */
+  excludeTargets?: string[];
+  /** Alias for `excludeTargets`. */
+  exclude?: string[];
+  /**
+   * Force activation of a registered target id even when `detect` is false
+   * (e.g. CLI `--target cursor`). Alias: `forceTarget`.
+   */
+  forcedTarget?: string;
+  /** Alias for `forcedTarget`. */
+  forceTarget?: string;
+  /** Injected target registry (from @b-apm/integration-api). */
+  integrationRegistry?: IntegrationRegistry;
+  /** Alias accepted by acceptance helpers. */
+  registry?: IntegrationRegistry;
+  /** Override active target ids (else from manifest / detection / forced). */
+  activeTargets?: string[];
+  /**
+   * Download concurrency (default aligned with APM = 4). `0` = serial.
+   */
+  parallelDownloads?: number;
+  maxDepth?: number;
+  verbose?: boolean;
+  gitRemote?: GitRemote;
+  tagLister?: TagLister;
+  downloader?: Downloader;
+  /**
+   * Local pack zip path — extract into project root before install orchestration
+   * (M7 install-from-archive round-trip).
+   */
+  archivePath?: string;
+  /** Explicit policy file path (`--policy`). */
+  policyPath?: string;
+  /** Alias for `policyPath`. */
+  policy?: string;
+  /** Skip policy discovery + checks (`--no-policy` / env disable). */
+  noPolicy?: boolean;
+  /** Override ordered policy discovery providers. */
+  policyProviders?: string[];
+  /** Alias for `policyProviders`. */
+  providers?: string[];
+  /** Injectable git remotes for pl-012 / remote discovery. */
+  listGitRemotes?: (cwd?: string) => Array<{
+    name: string;
+    url: string;
+  }>;
+  remotes?: Array<{
+    name: string;
+    url: string;
+  }>;
+  /** Injectable HTTP for remote policy / extends. */
+  fetchPolicyUrl?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  httpGet?: (url: string) => {
+    ok?: boolean;
+    text?: string;
+    body?: string;
+    status?: number;
+    url?: string;
+  };
+  /** Injectable extends ancestor fetcher. */
+  fetchAncestor?: (ref: string, context: {
+    leafHostClass: string;
+    chain: string[];
+  }) => unknown;
+  /** When remote fetch fails before a document exists (pl-010). */
+  defaultFetchFailure?: "off" | "warn" | "block";
+  implementationDefaultHost?: string;
+  /**
+   * Deploy transitive (dependency) MCP servers when no grant surface applies
+   * (`--trust-transitive-mcp`). Direct `dependencies.mcp` always eligible.
+   */
+  trustTransitiveMcp?: boolean;
+  experimentalRegistries?: boolean;
+  registryBaseUrl?: string;
+  mirrorUrl?: string;
+  /** Override `~/.bapm` for marketplace registry during install resolve. */
+  marketplaceConfigDir?: string;
+  configDir?: string;
+};
+/** Alias for design naming flexibility. */
+type InstallOptions = RunInstallOptions;
+type InstallResult = {
+  ok: true;
+  lockPath?: string;
+  modulesDir: string;
+  activeTargets: string[];
+  primitivesCount: number;
+  diagnostics: unknown[];
+  /** Policy gate warnings / findings (M8). */
+  policyDiagnostics?: unknown[];
+  /** True when install returned after dry-run preview (no durable writes). */
+  dryRun?: boolean;
+};
+type EnforceFrozenOptions = {
+  cwd?: string;
+  updateRefs?: boolean;
+  update?: boolean;
+};
+//#endregion
+//#region src/modules/Install/errors.d.ts
+type InstallErrorCode = "INSTALL_FROZEN_NO_LOCK" | "INSTALL_FROZEN_MISSING_PIN" | "INSTALL_FROZEN_UPDATE_REJECTED" | "INSTALL_FROZEN_HASH_MISMATCH" | "INSTALL_FROZEN_POSITIONAL" | "INSTALL_UNKNOWN_TARGET" | "INSTALL_UNKNOWN_EXCLUDE" | "INSTALL_TARGET_FIELDS" | "INSTALL_ARCHIVE" | "INSTALL_PACKAGE_REF" | "INSTALL_MCP_TRUST" | "INSTALL_MCP_ENV_BAKE" | "INSTALL_INSECURE" | "INSTALL_INVALID_HOST" | "INSTALL_FAILED";
+declare class InstallError extends Error {
+  readonly code: InstallErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: InstallErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Install/frozen.d.ts
+/**
+ * Basic frozen gate (lk-006): reject frozen+update; require lock; require direct pins.
+ * Call before any modules/lock/target mutation.
+ */
+declare function enforceFrozen(options?: EnforceFrozenOptions): void;
+//#endregion
+//#region src/modules/Install/ciFrozen.d.ts
+/**
+ * OpenAPM req-lk-018: CI truthiness and effective frozen resolution.
+ *
+ * Truthy CI: variable present and not "", "0", or "false" (case-insensitive).
+ * Only the `CI` key is consulted — vendor vars (GITHUB_ACTIONS, …) do not imply CI.
+ */
+type ResolveEffectiveFrozenOptions = {
+  /** Explicit `--frozen` / force-on. */
+  frozen?: boolean;
+  /** Explicit `--no-frozen` opt-out. */
+  noFrozen?: boolean;
+  /** Env map (defaults to empty — callers pass `process.env` or a test stub). */
+  env?: Record<string, string | undefined>;
+};
+/**
+ * OpenAPM CI truthiness: `CI` present and not `""` / `"0"` / `"false"` (case-insensitive).
+ */
+declare function isCiEnvTruthy(env?: Record<string, string | undefined>): boolean;
+/**
+ * Resolve effective frozen mode from flags + env.
+ *
+ * Precedence: `--frozen`+`--no-frozen` conflict → throw;
+ * else `--no-frozen` → false;
+ * else `--frozen` OR truthy CI → true;
+ * else false.
+ */
+declare function resolveEffectiveFrozen(options?: ResolveEffectiveFrozenOptions): boolean;
+//#endregion
+//#region src/modules/Install/runInstall.d.ts
+/**
+ * Run install: optional archive extract → frozen gate → plan → policy gate →
+ * download → orphan cleanup → primitives → targets → MCP trust/configure →
+ * write deployed_file_hashes / mcp_* lock fields.
+ *
+ * With `dryRun: true`, returns after direct-deps (+ MCP view) preview and optional
+ * policy preflight — no durable project writes and no target write ports.
+ */
+declare function runInstall(options?: RunInstallOptions): Promise<InstallResult>;
+/** Alias preferred by design docs. */
+declare const installProject: typeof runInstall;
+//#endregion
+//#region src/modules/Install/targets.d.ts
+/**
+ * Surface declared target id(s) from a manifest for Install intersection (tg-008).
+ * Accepts vendor ids `x-<vendor>-<name>` without requiring a registered impl (tg-004).
+ * Object-map forms contribute their keys (host ids); values are ignored here.
+ */
+declare function declaredTargetIds(manifest: BapmManifest): string[];
+/**
+ * When `target` / `targets` used the object-map form, return the retained
+ * host→package map. Legacy string/array forms → `undefined`.
+ * CLI composition loads/registers these packages before install/compile selection.
+ */
+declare function declaredTargetIntegrationMap(manifest: BapmManifest): Readonly<TargetIntegrationMap> | undefined;
+//#endregion
+//#region src/modules/Install/deployedInventory.d.ts
+/** Documented stable hash for deployed_file_hashes. */
+declare const DEPLOYED_HASH_ALGO: "sha256";
+declare function hashFileBytes(content: Buffer | string): string;
+declare function hashFileAt(absPath: string): string;
+/** Ensure relative path stays inside cwd (no escape). */
+declare function safeResolveUnderCwd(cwd: string, relPath: string): string | undefined;
+/**
+ * Remove harness files recorded in previous lock for deps no longer in the resolve set.
+ * No-op when inventory is absent. Never deletes paths outside recorded inventory.
+ */
+declare function cleanupOrphanDeployedFiles(args: {
+  cwd: string;
+  previous: LockfileDocument | null | undefined;
+  currentDepNames: Set<string>;
+}): string[];
+type DeployedHashViolation = {
+  path: string;
+  kind: "missing" | "mismatch";
+  expected?: string;
+  actual?: string;
+  message: string;
+};
+/**
+ * Collect deployed hash / presence violations without throwing (for audit --ci).
+ * No-op (empty) when no inventory present. tree_sha256 is handled separately via
+ * `collectTreeSha256Violations` (lk-015).
+ */
+declare function collectDeployedHashViolations(args: {
+  cwd: string;
+  document: LockfileDocument;
+}): DeployedHashViolation[];
+/**
+ * Re-verify on-disk content against lock deployed_file_hashes (lk-017 lite).
+ * No-op when no inventory present.
+ */
+declare function verifyDeployedFileHashes(args: {
+  cwd: string;
+  document: LockfileDocument;
+}): void;
+type ResolvedDeployedFile = {
+  path: string;
+  hash: string;
+  primitive?: {
+    name: string;
+    packageName?: string;
+  };
+};
+/** Normalize materialize return / void into path+hash list (core hashes when omitted). */
+declare function collectDeployedHashes(cwd: string, report: void | MaterializeReport | null | undefined): ResolvedDeployedFile[];
+/**
+ * Attach deployed_file_hashes onto lock dependency entries (by contributing package).
+ * Unattributed paths go to document-level local_deployed_file_hashes.
+ * Returns whether any hashes were written.
+ */
+declare function applyDeployedHashesToLock(args: {
+  document: LockfileDocument;
+  deployed: ResolvedDeployedFile[];
+  primitives: AttributedPrimitive[];
+}): boolean;
+//#endregion
+//#region src/modules/Update/types.d.ts
+type UpdatePlanEntry = {
+  name: string;
+  action: "update" | "add" | "remove" | "keep";
+  from?: string;
+  to?: string;
+};
+type RunUpdateOptions = {
+  cwd?: string;
+  /** Apply without interactive confirm. */
+  yes?: boolean;
+  /** Plan only; no lock/modules mutation. */
+  dryRun?: boolean;
+  "dry-run"?: boolean;
+  /** Frozen context — refuse without override. */
+  frozen?: boolean;
+  /** Explicit override to allow update under frozen (not used in M6 accept). */
+  force?: boolean;
+  override?: boolean;
+  /** Package scope (rs-012). */
+  packages?: string[];
+  scope?: string[];
+  updatePackageNames?: string[];
+  gitRemote?: GitRemote;
+  tagLister?: TagLister;
+  downloader?: Downloader;
+  parallelDownloads?: number;
+  maxDepth?: number;
+  /**
+   * When true, plan text includes `keep` / `[=]` rows.
+   * Default quiet: keep rows are omitted from printed text (plan array stays full).
+   */
+  verbose?: boolean;
+  /** Injected confirm for TTY tests; return true to apply. */
+  confirm?: () => boolean | Promise<boolean>;
+  /** Whether stdin is a TTY (default: process.stdin.isTTY). */
+  isTTY?: boolean;
+  /** Explicit policy file path. */
+  policyPath?: string;
+  policy?: string;
+  /** Skip policy gate. */
+  noPolicy?: boolean;
+};
+type UpdateResult = {
+  ok: boolean;
+  exitCode: number;
+  dryRun: boolean;
+  plan: UpdatePlanEntry[];
+  text: string;
+  lockPath?: string;
+};
+//#endregion
+//#region src/modules/Update/errors.d.ts
+type UpdateErrorCode = "UPDATE_FROZEN_REFUSED" | "UPDATE_CONFIRM_REQUIRED" | "UPDATE_FAILED";
+declare class UpdateError extends Error {
+  readonly code: UpdateErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: UpdateErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Update/runUpdate.d.ts
+/**
+ * Plan and optionally apply a full/scoped dependency update.
+ */
+declare function runUpdate(options?: RunUpdateOptions): Promise<UpdateResult>;
+declare const updateProject: typeof runUpdate;
+//#endregion
+//#region src/modules/Outdated/types.d.ts
+type OutdatedStatus = "outdated" | "up-to-date" | "unknown";
+type OutdatedRow = {
+  name: string;
+  status: OutdatedStatus;
+  current?: string;
+  latest?: string;
+  repo_url?: string;
+  /** Tip ref used for the check (verbose / diagnostics). */
+  tip_ref?: string;
+  /** Skip / path reason when verbose. */
+  detail?: string;
+};
+/** APM-aligned default for remote outdated checks. */
+declare const DEFAULT_PARALLEL_CHECKS = 4;
+type RunOutdatedOptions = {
+  cwd?: string;
+  gitRemote?: GitRemote;
+  tagLister?: TagLister;
+  /** Richer human-readable detail (chosen tip, skip reasons, candidates). */
+  verbose?: boolean;
+  /**
+   * Max concurrent remote checks (default 4). `0` = serial.
+   * Unresolved/`undefined` resolves to {@link DEFAULT_PARALLEL_CHECKS}.
+   */
+  parallelChecks?: number;
+};
+type OutdatedResult = {
+  ok: boolean;
+  exitCode: number;
+  rows: OutdatedRow[];
+  text: string;
+  message?: string;
+};
+//#endregion
+//#region src/modules/Outdated/errors.d.ts
+type OutdatedErrorCode = "OUTDATED_NO_LOCK" | "OUTDATED_FAILED";
+declare class OutdatedError extends Error {
+  readonly code: OutdatedErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: OutdatedErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Outdated/runOutdated.d.ts
+/**
+ * Compare lock pins to remote tips / latest matching semver tags.
+ * Exit 0 even when outdated rows exist; no lock → throw / non-success.
+ * Read-only: never writes project artifacts.
+ */
+declare function runOutdated(options?: RunOutdatedOptions): Promise<OutdatedResult>;
+declare const checkOutdated: typeof runOutdated;
+declare const outdated: typeof runOutdated;
+//#endregion
+//#region src/modules/Outdated/revisionPin.d.ts
+type AnnotatedTagCandidate = {
+  tag: string;
+  commit: string;
+};
+declare function isFullRevisionPin(ref: string | undefined | null): boolean;
+declare function abbreviateSha(sha: string, n?: number): string;
+/** Basename for `{name}` tag patterns (repo URL or `path:` virtual). */
+declare function packageBasenameFromRepo(repoUrl: string): string;
+/**
+ * Highest non-prerelease annotated semver tag (APM `find_latest_annotated_tag`).
+ * Only `annotated === true`; lightweight / missing evidence excluded (fail-closed).
+ */
+declare function findLatestAnnotatedTag(tags: FakeTag[], packageName: string): AnnotatedTagCandidate | null;
+//#endregion
+//#region src/modules/Uninstall/types.d.ts
+type RunUninstallOptions = {
+  cwd?: string;
+  packages?: string[];
+  names?: string[];
+  dryRun?: boolean;
+  "dry-run"?: boolean;
+};
+type UninstallResult = {
+  ok: boolean;
+  exitCode: number;
+  dryRun: boolean;
+  removed: string[];
+  text: string;
+  plan?: string[];
+};
+//#endregion
+//#region src/modules/Uninstall/errors.d.ts
+type UninstallErrorCode = "UNINSTALL_UNKNOWN" | "UNINSTALL_NO_PACKAGES" | "UNINSTALL_FAILED";
+declare class UninstallError extends Error {
+  readonly code: UninstallErrorCode;
+  readonly details?: Record<string, unknown>;
+  constructor(code: UninstallErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Uninstall/runUninstall.d.ts
+/**
+ * Remove named packages from manifest + modules + deployed inventory + lock.
+ */
+declare function runUninstall(options?: RunUninstallOptions): Promise<UninstallResult>;
+declare const uninstallPackages: typeof runUninstall;
+declare const uninstall: typeof runUninstall;
+//#endregion
+//#region src/modules/Prune/types.d.ts
+type RunPruneOptions = {
+  cwd?: string;
+  dryRun?: boolean;
+  "dry-run"?: boolean;
+};
+type PruneResult = {
+  ok: boolean;
+  exitCode: number;
+  dryRun: boolean;
+  orphans: string[];
+  removed: string[];
+  text: string;
+};
+//#endregion
+//#region src/modules/Prune/errors.d.ts
+type PruneErrorCode = "PRUNE_FAILED";
+declare class PruneError extends Error {
+  readonly code: PruneErrorCode;
+  constructor(code: PruneErrorCode, message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Prune/runPrune.d.ts
+/**
+ * Remove package dirs under apm_modules that are not in the lock graph.
+ */
+declare function runPrune(options?: RunPruneOptions): Promise<PruneResult>;
+declare const pruneModules: typeof runPrune;
+declare const prune: typeof runPrune;
+//#endregion
+//#region src/modules/Deps/types.d.ts
+type RunDepsOptions = {
+  cwd?: string;
+  package?: string;
+  name?: string;
+  packages?: string[];
+};
+type DepsListResult = {
+  ok: boolean;
+  exitCode: number;
+  packages: Array<Record<string, unknown>>;
+  text: string;
+};
+type DepsTreeResult = {
+  ok: boolean;
+  exitCode: number;
+  tree: unknown;
+  text: string;
+};
+/** Identity + inspect meta for a lock package in why output. */
+type DepsWhyPackage = {
+  name?: string;
+  repo_url?: string;
+  version: string;
+  source: string;
+  is_direct: boolean;
+};
+/** One node in a why path chain (root → target). */
+type DepsWhyPathNode = {
+  name?: string;
+  repo_url?: string;
+  constraint: string | null;
+  is_direct: boolean;
+};
+type DepsWhyPath = {
+  chain: DepsWhyPathNode[];
+};
+type DepsWhyError = "no_lockfile" | "not_installed" | "ambiguous";
+type DepsWhyResult = {
+  ok: boolean;
+  exitCode: number;
+  chains: string[][];
+  text: string;
+  package?: DepsWhyPackage;
+  paths?: DepsWhyPath[];
+  error?: DepsWhyError;
+  query?: string;
+  matches?: Array<{
+    name?: string;
+    repo_url?: string;
+  }>;
+};
+//#endregion
+//#region src/modules/Deps/listDeps.d.ts
+declare function listDeps(options?: RunDepsOptions): DepsListResult;
+declare const depsList: typeof listDeps;
+declare const runDepsList: typeof listDeps;
+//#endregion
+//#region src/modules/Deps/treeDeps.d.ts
+declare function treeDeps(options?: RunDepsOptions): DepsTreeResult;
+declare const depsTree: typeof treeDeps;
+declare const runDepsTree: typeof treeDeps;
+//#endregion
+//#region src/modules/Deps/resolvePackageQuery.d.ts
+/**
+ * Staged resolve: exact name|repo_url → unique owner/repo → unique basename.
+ * Stop at the first form with ≥1 match (ambiguous if ≥2 at that form).
+ */
+declare function resolvePackageQuery(deps: LockedDependency[], query: string): LockedDependency[];
+/** Last path segment of `repo_url`, trailing `.git` stripped. */
+declare function repoBasename(repoUrl: string): string | null;
+/**
+ * Last two path segments as `owner/repo` (`.git` stripped on repo).
+ * Fewer than two segments → full trimmed `repo_url` as identity.
+ */
+declare function repoOwnerRepo(repoUrl: string): string | null;
+//#endregion
+//#region src/modules/Deps/whyDeps.d.ts
+/**
+ * Offline reverse walk from lock edges (rs-005 SHOULD).
+ * Honest exits: 0 success, 1 not_installed/ambiguous, 2 no_lockfile.
+ */
+declare function whyDeps(options?: RunDepsOptions): DepsWhyResult;
+declare const depsWhy: typeof whyDeps;
+declare const runDepsWhy: typeof whyDeps;
+//#endregion
+//#region src/modules/Audit/types.d.ts
+type AuditCiFormat = "text" | "json" | "sarif";
+type RunAuditCiOptions = {
+  cwd?: string;
+  ci?: boolean;
+  /** When set, `body` is the serialized document and `text` mirrors it for json/sarif. */
+  format?: AuditCiFormat;
+};
+type AuditCiCheckName = "lockfile-exists" | "content-integrity" | "tree-sha256";
+type AuditCiCheck = {
+  name: AuditCiCheckName;
+  passed: boolean;
+  message: string;
+  details: string[];
+  /**
+   * Project-relative URIs aligned with `details` (or a single fallback) for SARIF.
+   * Omitted from JSON serialization.
+   */
+  locations?: string[];
+};
+type AuditCiSummary = {
+  total: number;
+  passed: number;
+  failed: number;
+};
+type AuditCiStructuredReport = {
+  passed: boolean;
+  checks: AuditCiCheck[];
+  summary: AuditCiSummary;
+};
+type AuditCiResult = {
+  ok: boolean;
+  exitCode: number;
+  violations: string[];
+  diagnostics: string[];
+  text: string;
+  checks: AuditCiCheck[];
+  /** Same as overall gate: true iff every check passed. */
+  passed: boolean;
+  summary: AuditCiSummary;
+  /** Relative lock path when discovered (SARIF fallback uri). */
+  lockRelativePath?: string;
+  /** Serialized body when `format` was json/sarif. */
+  body?: string;
+};
+//#endregion
+//#region src/modules/Audit/runAuditCi.d.ts
+/**
+ * CI gate: lock present; deployed files present; hash re-verify (lk-017/sc-001);
+ * git tree_sha256 re-verify (lk-015) — fail-closed on missing/mismatch.
+ * Always emits three structured checks in fixed order.
+ */
+declare function runAuditCi(options?: RunAuditCiOptions): Promise<AuditCiResult>;
+declare const auditCi: typeof runAuditCi;
+declare const runAudit: typeof runAuditCi;
+//#endregion
+//#region src/modules/Audit/formatAuditCi.d.ts
+declare function summarizeChecks(checks: AuditCiCheck[]): AuditCiSummary;
+declare function toStructuredReport(result: AuditCiResult): AuditCiStructuredReport;
+/**
+ * Pure JSON serializer (indent 2, stable top-level key order: passed → checks → summary).
+ */
+declare function formatAuditCiJson(result: AuditCiResult): string;
+/**
+ * Pure SARIF 2.1.0 serializer. No snippets / no file body regions.
+ */
+declare function formatAuditCiSarif(result: AuditCiResult): string;
+//#endregion
+//#region src/modules/Export/types.d.ts
+/** Supported SBOM format identifiers (case-insensitive). */
+declare const FORMAT_CYCLONEDX = "cyclonedx";
+declare const FORMAT_SPDX = "spdx";
+declare const SUPPORTED_FORMATS: readonly ["cyclonedx", "spdx"];
+type SbomFormat = (typeof SUPPORTED_FORMATS)[number];
+declare const CYCLONEDX_SPEC_VERSION = "1.5";
+declare const SPDX_VERSION = "SPDX-2.3";
+declare const FIXED_EPOCH_TIMESTAMP = "1970-01-01T00:00:00Z";
+type ExportSbomOptions = {
+  /** In-memory lock document; when omitted, load from `cwd`. */
+  document?: LockfileDocument | LockfileInput | Record<string, unknown>;
+  /** Project root for lock discovery when `document` is omitted. */
+  cwd?: string;
+  /** `cyclonedx` (default) or `spdx`. */
+  format?: string;
+  /** Explicit ISO timestamp (wins over SOURCE_DATE_EPOCH / generated_at). */
+  timestamp?: string;
+};
+type ExportSbomSuccess = {
+  ok: true;
+  json: string;
+  format: SbomFormat;
+};
+type ExportSbomFailure = {
+  ok: false;
+  error: string;
+};
+type ExportSbomResult = ExportSbomSuccess | ExportSbomFailure;
+type InventoryDep = LockedDependency & {
+  declared_license?: string;
+  content_hash?: string;
+  host_type?: string;
+};
+//#endregion
+//#region src/modules/Export/purl.d.ts
+/**
+ * Remove embedded credentials from *url* before it appears in SBOM output.
+ * Drops userinfo and the entire query string; keeps scheme/host/port/path/fragment.
+ */
+declare function scrubUrl(url: string): string;
+/** Build the Package URL identity for *dep* from lockfile fields only. */
+declare function buildPurl(dep: InventoryDep): string;
+declare function componentName(dep: InventoryDep): string;
+declare function componentVersion(dep: InventoryDep): string | undefined;
+//#endregion
+//#region src/modules/Export/license.d.ts
+/**
+ * Offline SPDX declared-license classifier (APM-aligned three-state).
+ * Uses a compact built-in id set; unrecognized strings render as named, never rejected.
+ */
+declare const KIND_ID = "id";
+declare const KIND_EXPRESSION = "expression";
+declare const KIND_NAMED = "named";
+type LicenseKind = typeof KIND_ID | typeof KIND_EXPRESSION | typeof KIND_NAMED;
+type LicenseClass = {
+  kind: LicenseKind;
+  value: string;
+};
+/** Classify a non-empty declared license string for SBOM rendering. */
+declare function classifyDeclaredLicense(declared: string): LicenseClass;
+//#endregion
+//#region src/modules/Export/serialize.d.ts
+declare function normalizeFormat(fmt: string | undefined): SbomFormat | null;
+declare function formatUnsupportedMessage(fmt: string): string;
+/** Serialize lock inventory to deterministic SBOM JSON (indent 2, sorted keys, trailing newline). */
+declare function serializeSbom(document: LockfileDocument | LockfileInput, format: SbomFormat, timestamp: string): string;
+//#endregion
+//#region src/modules/Export/exportSbom.d.ts
+/**
+ * Export an SBOM inventory from lock fields only (no resolve / network / mutation).
+ */
+declare function exportSbom(options?: ExportSbomOptions): Promise<ExportSbomResult>;
+//#endregion
+//#region src/modules/Doctor/types.d.ts
+type DoctorCheck = {
+  name: string;
+  ok: boolean;
+  critical: boolean;
+  message: string;
+};
+type RunDoctorOptions = {
+  cwd?: string;
+  /** When true, enrich domain messages and run verbose-only probes (e.g. network). */
+  verbose?: boolean;
+  gitAvailable?: boolean;
+  hasGit?: boolean;
+  whichGit?: () => string | null | undefined;
+  findGit?: () => string | null | undefined;
+};
+type DoctorResult = {
+  ok: boolean;
+  exitCode: number;
+  checks: DoctorCheck[];
+  text: string;
+};
+//#endregion
+//#region src/modules/Doctor/runDoctor.d.ts
+declare function runDoctor(options?: RunDoctorOptions): Promise<DoctorResult>;
+declare const doctor: typeof runDoctor;
+declare const checkDoctor: typeof runDoctor;
+//#endregion
+//#region src/modules/Pack/types.d.ts
+type RunPackOptions = {
+  cwd?: string;
+  /** Pack an Agent Plugins v1 portable root (never a marketplace output). */
+  agentPlugins?: boolean;
+  /** Produce a durable archive (MUST path for M7). */
+  archive?: boolean;
+  /** Archive format; only `zip` is supported in M7. */
+  format?: string;
+  /** Validate and collect without writing a durable artifact. */
+  dryRun?: boolean;
+  /** Explicit output zip path; defaults to `{name}-{version}.zip` under cwd. */
+  outputPath?: string;
+  /** Also run pr-004 release gate before packing. */
+  checkRelease?: boolean;
+  /** Tag override for `--check-release`. */
+  tag?: string;
+  /**
+   * CLI `--marketplace` filter: `all` | `none` | comma list / string[].
+   * When omitted, emit all formats enabled in authoring `outputs`.
+   */
+  marketplace?: string | string[];
+  /** CLI `--marketplace-path FORMAT=PATH` overrides. */
+  marketplacePaths?: Record<string, string> | string[];
+  /** Fail-closed remote resolve without network. */
+  offline?: boolean;
+  /** Include prerelease tags when resolving version ranges. */
+  includePrerelease?: boolean;
+  /** Composition-root registry of marketplace-output integrations. */
+  marketplaceOutputs?: MarketplaceOutputRegistry;
+  /** Injectable ls-remote for tests (forwarded to marketplace builder). */
+  lsRemote?: (repoUrl: string, ref?: string) => Promise<{
+    sha: string;
+    ref: string;
+  }> | {
+    sha: string;
+    ref: string;
+  };
+};
+type RunPackResult = {
+  ok: true;
+  dryRun: boolean;
+  archivePath?: string;
+  filesPacked: number;
+  marketplaceWritten?: boolean;
+};
+type ExtractPackArchiveOptions = {
+  /** Absolute or relative path to the zip archive. */
+  archivePath?: string;
+  /** Alias for `archivePath`. */
+  path?: string;
+  /** Project / extract root (aliases: `outputDir`, `dest`). */
+  cwd?: string;
+  outputDir?: string;
+  dest?: string;
+};
+type ExtractPackArchiveResult = {
+  ok: true;
+  outputDir: string;
+  filesExtracted: number;
+};
+type CheckReleaseTagOptions = {
+  cwd?: string;
+  /** Explicit release tag (optional leading `v`). */
+  tag?: string;
+  /**
+   * When true, treat the tag as unsigned for pr-005 advisory.
+   * MUST NOT fail solely for unsigned in M7.
+   */
+  unsigned?: boolean;
+  /** Hard-require signature — ignored as fail condition in M7 (advisory only). */
+  requireSignature?: boolean;
+};
+type CheckReleaseTagResult = {
+  ok: true;
+  exitCode: 0;
+  tag: string;
+  version: string;
+  warnings: string[];
+};
+//#endregion
+//#region src/modules/Pack/errors.d.ts
+/** Typed diagnostics for pack / extract / release-gate. */
+type PackErrorCode = "PACK_VALIDATION" | "PACK_SECRET_REFUSED" | "PACK_IO" | "PACK_EXTRACT" | "RELEASE_TAG_MISSING" | "RELEASE_TAG_INVALID" | "RELEASE_TAG_MISMATCH";
+declare class PackError extends Error {
+  readonly code: PackErrorCode;
+  readonly path?: string;
+  readonly details?: Record<string, unknown>;
+  constructor(code: PackErrorCode, message: string, options?: {
+    path?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/modules/Pack/runPack.d.ts
+/**
+ * Validate project manifest, collect pack set, refuse secrets, optionally write plain zip.
+ * When marketplace authoring + outputs are selected, emit host marketplace.json (design D1–D2).
+ * When `checkRelease` is set, runs pr-004 gate first (fail closed before durable zip).
+ */
+declare function runPack(options?: RunPackOptions): Promise<RunPackResult>;
+/** Alias accepted by acceptance helpers. */
+declare const packProject: typeof runPack;
+declare const packArchive: typeof runPack;
+//#endregion
+//#region src/modules/Pack/extract.d.ts
+/**
+ * Extract a pack-produced plain zip into an output directory.
+ * Expects dual-read manifest at archive root after extract.
+ * Uses shared safe-extract (symlink / path-escape / caps / fail-closed cleanup).
+ */
+declare function extractPackArchive(options?: ExtractPackArchiveOptions): Promise<ExtractPackArchiveResult>;
+/** Aliases for acceptance helpers. */
+declare const unpackArchive: typeof extractPackArchive;
+declare const extractPack: typeof extractPackArchive;
+//#endregion
+//#region src/modules/Pack/safeExtract.d.ts
+declare const MAX_SAFE_ENTRIES = 10000;
+declare const MAX_SAFE_UNCOMPRESSED_BYTES: number;
+declare class SafeExtractError extends Error {
+  readonly path?: string;
+  constructor(message: string, options?: {
+    path?: string;
+    cause?: unknown;
+  });
+}
+type ZipCdEntry = {
+  name: string;
+  uncompressedSize: number;
+  compressedSize: number;
+  externalAttr: number;
+  createSystem: number;
+  isDirectory: boolean;
+};
+/**
+ * Parse zip central-directory entries (names, sizes, unix external_attr).
+ */
+declare function parseZipCentralDirectory(bytes: Uint8Array): ZipCdEntry[];
+/**
+ * Pre-scan CD: paths, symlink/non-regular, entry + size caps (fail before write).
+ */
+declare function assertSafeZipCentralDirectory(entries: ZipCdEntry[]): void;
+type SafeExtractZipResult = {
+  filesExtracted: number;
+  dest: string;
+};
+/**
+ * Fail-closed extract into `dest` via same-filesystem staging + rename.
+ * On any error, staging is removed and `dest` is not left as a half-write from this call.
+ */
+declare function safeExtractZip(bytes: Uint8Array, dest: string): SafeExtractZipResult;
+//#endregion
+//#region src/modules/Pack/checkRelease.d.ts
+/**
+ * pr-004: compare release tag (optional leading `v`) to manifest `version`.
+ * Never creates or pushes tags. pr-005 unsigned is advisory only.
+ */
+declare function checkReleaseTag(options?: CheckReleaseTagOptions): Promise<CheckReleaseTagResult>;
+/** Aliases for acceptance helpers. */
+declare const checkRelease: typeof checkReleaseTag;
+declare const runCheckRelease: typeof checkReleaseTag;
+//#endregion
+//#region src/modules/Pack/secrets.d.ts
+/**
+ * OpenAPM sc-007 producer secret-pattern refuse (fixed denylist for M7).
+ * Match against basename of paths that would enter the pack set.
+ */
+declare function isSecretPackPath(relativePath: string): boolean;
+declare function describeSecretRefuse(relativePath: string): string;
+//#endregion
+//#region src/modules/Auth/types.d.ts
+/**
+ * Shared Auth types — OpenAPM §10.3 credential host-class / resolve / git child env.
+ */
+type ProviderHostClass = "github" | "ghe_cloud" | "ghes" | "gitlab" | "ado" | "generic";
+type RegistryAliasEntry = {
+  url: string;
+  aliases?: string[];
+  insecure?: boolean;
+  [key: string]: unknown;
+};
+type RegistryAliasMap = Record<string, RegistryAliasEntry | string>;
+type ResolvedCredentials = {
+  /** Secret — never log. */
+  readonly token: string;
+  /** Env / source id for diagnostics (sc-007). */
+  readonly source: string;
+  /** Cache / scope key including class + host + port (sc-013 e). */
+  readonly cacheKey: string;
+  /** Explicit port when present (narrows lookup within class). */
+  readonly port?: number;
+  /** PSL / alias credential host-class. */
+  readonly credentialHostClass: string;
+  /** True when a credential was selected for attach. */
+  readonly attached: boolean;
+};
+type ResolveCredentialsOptions = {
+  host: string;
+  url?: string;
+  port?: number;
+  env?: NodeJS.ProcessEnv;
+  registries?: RegistryAliasMap;
+  /** Named registry for BAPM_REGISTRY_<NAME>_TOKEN. */
+  registryName?: string;
+};
+type SameCredentialHostClassOptions = {
+  registries?: RegistryAliasMap;
+  /** Ignored — redirects never collapse classes (sc-005). */
+  viaRedirect?: boolean;
+};
+type BuildGitChildEnvOptions = {
+  host: string;
+  url: string;
+  env?: NodeJS.ProcessEnv;
+  registries?: RegistryAliasMap;
+};
+type FetchWithRedirectAuthDropInit = RequestInit & {
+  /** Max redirect hops (default 10). */
+  maxRedirects?: number;
+  /** Alias map for credential class compare. */
+  registries?: RegistryAliasMap;
+};
+//#endregion
+//#region src/modules/Auth/credentialHostClass.d.ts
+/**
+ * Credential host-class = Public Suffix List eTLD+1 (registrable domain).
+ * Empty / invalid hostnames fall back to the normalized hostname string.
+ */
+declare function credentialHostClassOf(hostname: string): string;
+declare const credentialHostClass: typeof credentialHostClassOf;
+declare const authHostClassOf: typeof credentialHostClassOf;
+declare const hostClassForCredentials: typeof credentialHostClassOf;
+/**
+ * Build union: each aliases[] hostname joins the same credential class as the
+ * registry entry's `url` hostname.
+ */
+declare function buildAliasCredentialClassMap(registries?: RegistryAliasMap): Map<string, string>;
+/**
+ * Effective credential class for a hostname, applying registries.*.aliases union.
+ */
+declare function credentialHostClassForHost(hostname: string, registries?: RegistryAliasMap): string;
+/**
+ * Two hostnames share a credential class iff same PSL eTLD+1 or alias union.
+ * Redirect / CNAME / SAN observation MUST NOT collapse classes.
+ */
+declare function sameCredentialHostClass(a: string, b: string, options?: SameCredentialHostClassOptions): boolean;
+declare const credentialHostClassesEqual: typeof sameCredentialHostClass;
+declare const hostsShareCredentialClass: typeof sameCredentialHostClass;
+//#endregion
+//#region src/modules/Auth/selectProviderClass.d.ts
+declare function collectAdoHosts(env: NodeJS.ProcessEnv): Set<string>;
+/**
+ * Select exactly one provider class for a hostname.
+ * Precedence: ado allowlist → (GHES∩GitLab fail) → github.com / ghe.com /
+ * GITHUB_HOST → gitlab allowlist / gitlab.com → ado cloud → generic.
+ */
+declare function selectProviderClassForHost(host: string, env?: NodeJS.ProcessEnv): ProviderHostClass;
+declare const effectiveProviderClassForHost: typeof selectProviderClassForHost;
+declare const classifyProviderHostClass: typeof selectProviderClassForHost;
+//#endregion
+//#region src/modules/Auth/resolveCredentials.d.ts
+/**
+ * Resolve at most one credential for the host's selected class.
+ * Provider env tokens are never returned for a distinct registry host class,
+ * and registry tokens are never returned for github.com-class provider hosts.
+ */
+declare function resolveCredentialsForHost(options: ResolveCredentialsOptions): ResolvedCredentials | null;
+declare const resolveAuthCredentialsForHost: typeof resolveCredentialsForHost;
+declare const resolveHostCredentials: typeof resolveCredentialsForHost;
+/** Auth header map for a resolved credential + provider class. */
+declare function authHeadersForResolved(resolved: ResolvedCredentials | null, providerClass: ProviderHostClass): Record<string, string>;
+//#endregion
+//#region src/modules/Auth/fetchRedirectAuthDrop.d.ts
+/**
+ * Fetch with redirect: 'manual' hop budget; strip Auth on cross-class Location.
+ * Same-class redirects MAY retain Authorization.
+ */
+declare function fetchWithRedirectAuthDrop(input: string | URL | Request, init?: FetchWithRedirectAuthDropInit): Promise<Response>;
+declare const fetchRedirectAuthDrop: typeof fetchWithRedirectAuthDrop;
+declare const redirectSafeFetch: typeof fetchWithRedirectAuthDrop;
+declare const fetchWithCredentialHostClassRedirects: typeof fetchWithRedirectAuthDrop;
+//#endregion
+//#region src/modules/Auth/gitChildEnv.d.ts
+/** Platform token env names cleared before every consumer git spawn. */
+declare const PLATFORM_TOKEN_ENV_NAMES: readonly ["GITHUB_TOKEN", "GH_TOKEN", "GITHUB_APM_PAT", "GITLAB_TOKEN", "GITLAB_APM_PAT", "ADO_APM_PAT", "AZURE_DEVOPS_EXT_PAT", "SYSTEM_ACCESSTOKEN"];
+/**
+ * sc-008: refuse credential attach on non-https git-HTTP unless loopback or insecure.
+ * Ambient suppress still applies.
+ */
+declare function mayAttachGitCredential(options: {
+  url: string;
+  host: string;
+  registries?: RegistryAliasMap;
+}): boolean;
+/**
+ * Build env for a git child process:
+ * 1) clone parent env
+ * 2) clear platform token names
+ * 3) strip inherited Auth / http.extraheader
+ * 4) attach selected-class credential only when sc-008 allows
+ */
+declare function buildGitChildEnv(options: BuildGitChildEnvOptions): NodeJS.ProcessEnv;
+declare const buildHardenedGitEnv: typeof buildGitChildEnv;
+declare const createGitChildEnv: typeof buildGitChildEnv;
+declare const gitChildEnvForHost: typeof buildGitChildEnv;
+//#endregion
+//#region src/modules/ExecutableTrust/types.d.ts
+/** Grant entry for one package under allow/deny. */
+type ExecutableGrantEntry = {
+  mcp?: boolean;
+  [key: string]: unknown;
+};
+/**
+ * Parsed grant surface. `present` is true when the consuming manifest declared
+ * `executables.allow` / `allowExecutables` (even if empty).
+ */
+type ExecutableGrantSurface = {
+  present: boolean;
+  allow: Record<string, ExecutableGrantEntry>;
+  deny: Record<string, ExecutableGrantEntry>;
+};
+type ExecutableTrustOutcome = "allow" | "withhold" | "deny" | "skip";
+type ExecutableTrustDecision = {
+  allowed: boolean;
+  outcome: ExecutableTrustOutcome;
+  packageName: string;
+  executableType: string;
+  reason?: string;
+  withhold?: boolean;
+  unapproved?: boolean;
+};
+type GrantSurfaceInput = ExecutableGrantSurface | {
+  allow?: Record<string, unknown>;
+  deny?: Record<string, unknown>;
+  present?: boolean;
+} | null | undefined;
+type OrgExecutables = {
+  deny_all?: boolean;
+  deny?: string[];
+};
+type EvaluateExecutableTrustOptions = {
+  /** Parsed surface or raw `{ allow }` bag accepted by acceptance helpers. */
+  grantSurface?: GrantSurfaceInput;
+  packageName: string;
+  executableType?: string;
+  /** Alias for executableType. */
+  type?: string;
+};
+/** Layered deny-wins options (sc-011): org + project + user. */
+type ResolveExecutableTrustOptions = {
+  packageName: string;
+  executableType?: string;
+  type?: string;
+  orgExecutables?: OrgExecutables | null;
+  projectSurface?: GrantSurfaceInput;
+  userSurface?: GrantSurfaceInput;
+  /** Back-compat alias → projectSurface. */
+  grantSurface?: GrantSurfaceInput;
+};
+type ParseExecutableGrantsOptions = {
+  /** Manifest document (or bag with executables / allowExecutables). */
+  manifest?: Record<string, unknown>;
+  /** Direct grant bag when manifest is not passed. */
+  executables?: unknown;
+  allowExecutables?: unknown;
+};
+/** Lockfile-presence require evaluation (sc-012). */
+type RequiredPackageTrustOutcome = {
+  outcome?: string;
+  allowed?: boolean;
+  withhold?: boolean;
+  [key: string]: unknown;
+};
+type EvaluateRequiredPackagePresenceOptions = {
+  require?: string[];
+  lockPackageIds?: string[];
+  trustByPackage?: Record<string, RequiredPackageTrustOutcome>;
+};
+type RequiredPackagePresenceDiagnostic = {
+  code: string;
+  message: string;
+  identity?: string;
+};
+type EvaluateRequiredPackagePresenceResult = {
+  ok: boolean;
+  satisfied: boolean;
+  diagnostics: RequiredPackagePresenceDiagnostic[];
+  violations: RequiredPackagePresenceDiagnostic[];
+  codes: string[];
+};
+//#endregion
+//#region src/modules/ExecutableTrust/userStore.d.ts
+type UserExecutableStoreOptions = {
+  /** Override config root (defaults to `~/.bapm`). */
+  configRoot?: string;
+  /** Alias for configRoot (Marketplace / acceptance). */
+  configDir?: string;
+};
+type UserExecutableGrants = {
+  allow: Record<string, ExecutableGrantEntry>;
+  deny: Record<string, ExecutableGrantEntry>;
+  executables: {
+    allow: Record<string, ExecutableGrantEntry>;
+    deny: Record<string, ExecutableGrantEntry>;
+  };
+  /** True when config.json declared an `executables` key (even if empty). */
+  present: boolean;
+};
+type SaveUserExecutableGrantsOptions = UserExecutableStoreOptions & {
+  allow?: Record<string, unknown>;
+  deny?: Record<string, unknown>;
+  executables?: {
+    allow?: Record<string, unknown>;
+    deny?: Record<string, unknown>;
+  };
+  packageName?: string;
+  grant?: "allow" | "deny";
+  executableType?: string;
+};
+/** Resolve config root: explicit override → `~/.bapm`. */
+declare function resolveUserConfigRoot(opts?: UserExecutableStoreOptions): string;
+declare function userConfigJsonPath(opts?: UserExecutableStoreOptions): string;
+/**
+ * Load user-local executables grants from `<configRoot>/config.json`.
+ * Missing file → empty allow/deny (surface not present until keys exist).
+ */
+declare function loadUserExecutableGrants(opts?: UserExecutableStoreOptions): UserExecutableGrants;
+/** Alias preferred by acceptance helpers. */
+declare const loadUserExecutables: typeof loadUserExecutableGrants;
+declare const loadExecutableUserGrants: typeof loadUserExecutableGrants;
+declare const readUserExecutableGrants: typeof loadUserExecutableGrants;
+/**
+ * Save user-local executables grants to `<configRoot>/config.json`.
+ * Merges into existing JSON; prefers full `executables`/`allow`/`deny` bags,
+ * or incremental `packageName` + `grant` + `executableType`.
+ */
+declare function saveUserExecutableGrants(opts: SaveUserExecutableGrantsOptions): UserExecutableGrants;
+/** Alias preferred by acceptance helpers. */
+declare const saveUserExecutables: typeof saveUserExecutableGrants;
+declare const saveExecutableUserGrants: typeof saveUserExecutableGrants;
+declare const writeUserExecutableGrants: typeof saveUserExecutableGrants;
+declare const persistUserExecutableGrant: typeof saveUserExecutableGrants;
+/** Convert loaded user grants into a grant surface. */
+declare function userGrantsToSurface(grants: UserExecutableGrants, opts?: {
+  present?: boolean;
+}): ExecutableGrantSurface;
+//#endregion
+//#region src/modules/ExecutableTrust/evaluate.d.ts
+/**
+ * True when the consuming project declared a grant surface
+ * (`executables.allow` / `allowExecutables`), including an empty allow map.
+ */
+declare function hasGrantSurface(surface: ExecutableGrantSurface | {
+  present?: boolean;
+} | null | undefined): boolean;
+/**
+ * Parse grant vocabulary from a manifest document.
+ * Preferred: `executables.allow` / `executables.deny`.
+ * Alias: top-level `allowExecutables` (OpenAPM text drop-in).
+ */
+declare function parseExecutableGrants(input?: ParseExecutableGrantsOptions | Record<string, unknown>): ExecutableGrantSurface;
+/**
+ * Layered deny-wins resolver (sc-011):
+ * org deny_all / org deny → project|user deny → project allow → user allow →
+ * withhold if any grant surface present else skip.
+ */
+declare function resolveExecutableTrust(options: ResolveExecutableTrustOptions): ExecutableTrustDecision;
+/** Audit/trust classifier twin — identical to resolveExecutableTrust (sc-011). */
+declare const classifyExecutableTrust: typeof resolveExecutableTrust;
+/**
+ * Evaluate whether a package may deploy an executable type (default: mcp).
+ * Project-grant-only thin wrapper over `resolveExecutableTrust` (sc-009).
+ */
+declare function evaluateExecutableTrust(options: EvaluateExecutableTrustOptions): ExecutableTrustDecision;
+/** Alias preferred by acceptance helpers. */
+declare const evaluateMcpExecutableTrust: typeof evaluateExecutableTrust;
+/** Alias preferred by design docs. */
+declare const gateExecutableMcp: typeof evaluateExecutableTrust;
+/** Alias preferred by acceptance helpers. */
+declare const checkExecutableTrust: typeof evaluateExecutableTrust;
+//#endregion
+//#region src/modules/ExecutableTrust/presence.d.ts
+/**
+ * Evaluate `dependencies.require` from lockfile presence (sc-012).
+ * Present + MCP withheld → presence OK + distinct `EXEC_TRUST_WITHHELD`.
+ * Missing from lock → `POLICY_REQUIRE`.
+ */
+declare function evaluateRequiredPackagePresence(options?: EvaluateRequiredPackagePresenceOptions): EvaluateRequiredPackagePresenceResult;
+/** Alias preferred by acceptance helpers. */
+declare const classifyRequiredPackagePresence: typeof evaluateRequiredPackagePresence;
+declare const evaluateRequireLockPresence: typeof evaluateRequiredPackagePresence;
+declare const evaluateRequiredPackagesFromLock: typeof evaluateRequiredPackagePresence;
+//#endregion
+//#region src/modules/Mcp/types.d.ts
+type CollectedMcpServer = McpServerConfig & {
+  /** `direct` = root dependencies.mcp; `dependency` = from a package. */
+  origin: "direct" | "dependency";
+  packageName: string;
+};
+type CollectMcpServersOptions = {
+  cwd?: string;
+  rootManifest: BapmManifest;
+  nodes?: ResolvedNode[];
+  /** Deploy transitive MCP when no grant gate applies. */
+  trustTransitiveMcp?: boolean;
+  /** Parsed grant surface (when present, dep MCP is evaluated even without trust flag). */
+  grantSurface?: ExecutableGrantSurface;
+};
+type CollectMcpServersResult = {
+  /** Servers eligible for deploy after collection rules (before trust withhold). */
+  servers: CollectedMcpServer[];
+  /** Dependency packages that contributed MCP candidates needing trust evaluation. */
+  dependencyPackages: string[];
+  diagnostics: unknown[];
+};
+type ApplyMcpInventoryOptions = {
+  document: LockfileDocument;
+  servers: Array<{
+    name: string;
+    packageName?: string;
+    [key: string]: unknown;
+  }>;
+  configPath: string;
+  targetId: string;
+};
+//#endregion
+//#region src/modules/Mcp/bake.d.ts
+/**
+ * Bake-time resolution of MCP env/header placeholder syntaxes.
+ * Cursor path: legacy bake only (literals), no runtime translate-mode.
+ *
+ * Supported forms:
+ * - APM: `${VAR}` / `${env:VAR}` / legacy `<VAR>` (uppercase identifier only)
+ * - bapm-only: `{bake:NAME}` / `{bake:env:NAME}`
+ */
+type BakeMcpStringMapOptions = {
+  /** Prefer these over `env` / `process.env` when non-empty. */
+  overrides?: Record<string, string>;
+  /** Lookup environment; defaults to `process.env`. */
+  env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+  /**
+   * Project manifest top-level `env` defaults.
+   * Lookup order: overrides → process/`env` → `manifestEnv` (non-empty only).
+   */
+  manifestEnv?: Record<string, string>;
+  /**
+   * `bake` (default): resolve APM `${VAR}` / `${env:VAR}` / `<VAR>` and `{bake:NAME}`.
+   * `translate`: leave APM placeholders untouched; still resolve `{bake:NAME}` (fail-closed).
+   */
+  mode?: "bake" | "translate";
+};
+declare class McpEnvBakeError extends Error {
+  readonly code = "MCP_ENV_BAKE";
+  readonly missing: string[];
+  constructor(missing: string[]);
+}
+/**
+ * Resolve placeholders in a single string. Throws {@link McpEnvBakeError} if any
+ * required placeholder cannot be resolved to a non-empty value.
+ */
+declare function bakeMcpStringValue(value: string, options?: BakeMcpStringMapOptions): string;
+/**
+ * Bake-time resolve for MCP `env` / `headers` string maps.
+ * Values without placeholders pass through unchanged.
+ */
+declare function bakeMcpStringMap(map: Record<string, string>, options?: BakeMcpStringMapOptions): Record<string, string>;
+type BakeableMcpServer = {
+  env?: Record<string, string>;
+  headers?: Record<string, string>;
+  [key: string]: unknown;
+};
+/**
+ * Bake `env` and `headers` on a server config; other fields unchanged.
+ */
+declare function bakeMcpServerMaps<T extends BakeableMcpServer>(server: T, options?: BakeMcpStringMapOptions): T;
+//#endregion
+//#region src/modules/Mcp/collect.d.ts
+/**
+ * Collect MCP server definitions for deploy.
+ * - Direct `dependencies.mcp` always included.
+ * - Dependency MCP included when `--trust-transitive-mcp` OR grant surface is present
+ *   (caller still runs sc-009 withhold for unapproved packages).
+ */
+declare function collectMcpServers(options: CollectMcpServersOptions): CollectMcpServersResult;
+//#endregion
+//#region src/modules/Mcp/lockInventory.d.ts
+/**
+ * Populate lock top-level `mcp_*` fields from configured servers.
+ * Preserves unknown / `x-*` keys already on the document.
+ */
+declare function applyMcpInventoryToLock(options: ApplyMcpInventoryOptions): LockfileDocument;
+//#endregion
+//#region src/modules/Compile/types.d.ts
+type CompileAttributionEntry = {
+  name: string;
+  type: string;
+  path?: string;
+};
+type CompileAgentsMdOptions = {
+  cwd?: string;
+  /** When true, discover/validate only — do not write target output. */
+  validate?: boolean;
+  /** When true (and not validate), compute content but do not write. */
+  dryRun?: boolean;
+  /** When true, include thin attribution on the result for CLI printing. */
+  verbose?: boolean;
+  /** Target-relative output override; the target owns its default. */
+  outputFile?: string;
+  modulesDir?: string;
+  /** Registry of host target capabilities supplied by the application. */
+  integrationRegistry?: IntegrationRegistry;
+  /** Explicit registered target id, bypassing target detection. */
+  forcedTarget?: string;
+};
+type CompileAgentsMdResult = {
+  ok: boolean;
+  path?: string;
+  content: string;
+  wrote: boolean;
+  primitivesCount: number;
+  /** Thin source attribution (name / type / path when known). */
+  attribution: CompileAttributionEntry[];
+};
+//#endregion
+//#region src/modules/Compile/compileAgentsMd.d.ts
+/**
+ * Discover conflict-resolved primitives then delegate output emission to a
+ * selected registered target capability.
+ */
+declare function compileAgentsMd(options?: CompileAgentsMdOptions): Promise<CompileAgentsMdResult>;
+declare const compileProject: typeof compileAgentsMd;
+declare const runCompile: typeof compileAgentsMd;
+declare const emitAgentsMd: typeof compileAgentsMd;
+//#endregion
+//#region src/modules/Cache/types.d.ts
+type CacheInfoOptions = {
+  cwd?: string;
+  /** Override modules-cache root (default: `<cwd>/apm_modules`). */
+  cacheRoot?: string;
+};
+type CacheInfoResult = {
+  cacheRoot: string;
+  exists: boolean;
+  entries: number;
+  sizeBytes: number;
+  empty: boolean;
+  text: string;
+};
+type CacheCleanOptions = {
+  cwd?: string;
+  cacheRoot?: string;
+  /** Proceed without confirmation (`-y`). */
+  yes?: boolean;
+  /** Alias for yes. */
+  y?: boolean;
+  /**
+   * When true and `yes` is false, refuse to delete (non-interactive).
+   * Default true — callers must pass yes or confirm.
+   */
+  requireYes?: boolean;
+  /**
+   * Preview wipe: list would-remove entries, never delete, skip yes-refuse.
+   * `removedEntries` is the would-remove count; `cleaned` stays false.
+   */
+  dryRun?: boolean;
+};
+type CacheCleanResult = {
+  ok: boolean;
+  cleaned: boolean;
+  cacheRoot: string;
+  removedEntries: number;
+  message: string;
+  refused?: boolean;
+};
+//#endregion
+//#region src/modules/Cache/cacheOps.d.ts
+/**
+ * Report modules-cache root + size/entry stats (project `apm_modules`).
+ * Does not introduce a shared APM git/http cache (rs-016 identity preserved).
+ */
+declare function cacheInfo(options?: CacheInfoOptions): CacheInfoResult;
+declare const getCacheInfo: typeof cacheInfo;
+declare const modulesCacheInfo: typeof cacheInfo;
+/**
+ * Remove modules-cache content. Without `yes`/`-y`, refuses (non-silent).
+ * With `dryRun`, previews would-remove count/names and never deletes.
+ */
+declare function cacheClean(options?: CacheCleanOptions): CacheCleanResult;
+declare const cleanModulesCache: typeof cacheClean;
+//#endregion
+//#region src/modules/Registry/types.d.ts
+type RegistryHttpRequest = {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: Uint8Array | Buffer;
+};
+type RegistryHttpResponse = {
+  status: number;
+  headers: Record<string, string>;
+  body: Uint8Array;
+};
+/** Injectable HTTP transport for registry client (mock-friendly). */
+type RegistryHttpTransport = {
+  fetch(request: RegistryHttpRequest): Promise<RegistryHttpResponse>;
+};
+type CreateRegistryClientOptions = {
+  /** Registry base URL (aliases accepted by acceptance helpers). */
+  baseUrl?: string;
+  url?: string;
+  registryUrl?: string;
+  /** Bearer token; falls back to env when unset. */
+  token?: string;
+  /** Named registry key for `BAPM_REGISTRY_<NAME>_TOKEN`. */
+  registryName?: string;
+  /** Injectable transport (defaults to real fetch). */
+  transport?: RegistryHttpTransport;
+  /** JSON body hard cap for list responses (~10 MiB). */
+  maxJsonBytes?: number;
+};
+type RegistryVersionInfo = {
+  version: string;
+  digest: string;
+  published_at?: string;
+};
+type RegistryClient = {
+  baseUrl: string;
+  listVersions(owner: string, repo: string): Promise<RegistryVersionInfo[]>;
+  download(owner: string, repo: string, version: string): Promise<Uint8Array>;
+  publish(owner: string, repo: string, version: string, bytes: Uint8Array): Promise<void>;
+};
+type BuildPublishArchiveOptions = {
+  cwd?: string;
+  /** When true, still build bytes but callers skip PUT. */
+  dryRun?: boolean;
+  /** Optional docs to include at zip root. */
+  includeDocs?: boolean;
+};
+type BuildPublishArchiveResult = {
+  bytes: Uint8Array;
+  owner: string;
+  repo: string;
+  version: string;
+  name: string;
+};
+type CheckSelfUpdateOptions = {
+  currentVersion?: string;
+  /** npm registry base (or mock). Env: BAPM_SELF_UPDATE_METADATA_URL / BAPM_NPM_REGISTRY. */
+  registryUrl?: string;
+  packageName?: string;
+  /** dist-tag; default `latest`. */
+  distTag?: string;
+  /** Injectable metadata fetch. */
+  fetchMetadata?: (url: string) => Promise<unknown>;
+};
+type CheckSelfUpdateResult = {
+  currentVersion: string;
+  latestVersion?: string;
+  updateAvailable: boolean;
+  unknownVersion: boolean;
+  message: string;
+};
+//#endregion
+//#region src/modules/Registry/errors.d.ts
+type RegistryErrorCode = "REGISTRY_HTTP" | "REGISTRY_AUTH" | "REGISTRY_CONFLICT" | "REGISTRY_VALIDATION" | "REGISTRY_DIGEST" | "REGISTRY_GATE" | "REGISTRY_CONFIG" | "REGISTRY_PARSE" | "REGISTRY_PUBLISH" | "SELF_UPDATE";
+declare class RegistryError extends Error {
+  readonly code: RegistryErrorCode;
+  readonly details?: Record<string, unknown>;
+  readonly status?: number;
+  constructor(code: RegistryErrorCode, message: string, options?: {
+    details?: Record<string, unknown>;
+    cause?: unknown;
+    status?: number;
+  });
+}
+//#endregion
+//#region src/modules/Registry/gate.d.ts
+declare const EXPERIMENTAL_REGISTRIES_ENV = "BAPM_EXPERIMENTAL_REGISTRIES";
+declare function isExperimentalRegistriesEnabled(options?: {
+  experimentalRegistries?: boolean;
+  env?: NodeJS.ProcessEnv;
+}): boolean;
+declare function experimentalRegistriesRemediation(): string;
+declare function assertExperimentalRegistriesEnabled(options?: {
+  experimentalRegistries?: boolean;
+  env?: NodeJS.ProcessEnv;
+  action?: string;
+}): void;
+//#endregion
+//#region src/modules/Registry/createClient.d.ts
+declare function createRegistryClient(options?: CreateRegistryClientOptions): RegistryClient;
+declare function sha256Hex(content: Uint8Array | Buffer | string): string;
+declare function sha256Digest(content: Uint8Array | Buffer | string): string;
+/** Normalize and compare digests (`sha256:<hex>` or bare hex). */
+declare function digestsEqual(expected: string, actualHexOrDigest: string): boolean;
+declare function verifyArchiveDigest(bytes: Uint8Array, expectedDigest: string, options?: {
+  label?: string;
+}): string;
+//#endregion
+//#region src/modules/Registry/transport.d.ts
+/** Default real-fetch transport — redirect-safe for Authed requests (sc-003). */
+declare function createFetchTransport(): RegistryHttpTransport;
+declare function resolveRegistryToken(options?: {
+  token?: string;
+  registryName?: string;
+  env?: NodeJS.ProcessEnv;
+}): string | undefined;
+//#endregion
+//#region src/modules/Registry/publishArchive.d.ts
+/**
+ * Build flat registry publish zip: `apm.yml` at root + `.apm/**` (+ optional docs).
+ * Does NOT call M7 pack product API — zip I/O only via fflate.
+ * Wire `apm.yml` is serialized from the **dual-read base** only (no `bapm.local.yml` merge).
+ * Never includes personal overlay `bapm.local.yml` as a zip member.
+ */
+declare function buildPublishArchive(options?: BuildPublishArchiveOptions): BuildPublishArchiveResult;
+//#endregion
+//#region src/modules/Registry/selfUpdate.d.ts
+/**
+ * Compare running CLI version to npm dist-tag (primary metadata source).
+ * Injectable `fetchMetadata` for acceptance tests.
+ */
+declare function checkSelfUpdate(options?: CheckSelfUpdateOptions): Promise<CheckSelfUpdateResult>;
+//#endregion
+//#region src/modules/Registry/resolveHelpers.d.ts
+/**
+ * Resolve registry base URL from manifest `registries:` + per-dep name.
+ */
+declare function resolveRegistryBaseUrl(args: {
+  registries?: Record<string, RegistryEntry | string>;
+  registryName?: string;
+  /** Override (tests / CLI). */
+  registryBaseUrl?: string;
+}): {
+  baseUrl: string;
+  registryName?: string;
+};
+declare function parsePackageId(id: string): {
+  owner: string;
+  repo: string;
+};
+declare function registryRepoUrl(baseUrl: string, packageId: string): string;
+declare function downloadUrl(baseUrl: string, owner: string, repo: string, version: string): string;
+declare function pickRegistryVersion(versions: RegistryVersionInfo[], constraint: string): RegistryVersionInfo;
+type MaterializeRegistryPackageOptions = {
+  cwd: string;
+  dest: string;
+  bytes: Uint8Array;
+  expectedDigest: string;
+  label?: string;
+};
+/**
+ * lk-013: verify digest then shared safe-extract into dest. On mismatch, dest is untouched.
+ */
+declare function materializeRegistryArchive(options: MaterializeRegistryPackageOptions): void;
+declare function fetchAndMaterializeRegistry(args: {
+  cwd: string;
+  baseUrl: string;
+  owner: string;
+  repo: string;
+  version: string;
+  expectedDigest: string;
+  dest: string;
+  client?: RegistryClient;
+  /** Alternate fetch URL (rs-009 mirror) — still verify expectedDigest. */
+  fetchUrl?: string;
+}): Promise<Uint8Array>;
+declare function rewriteDownloadBase(resolvedUrl: string, mirrorBase: string): string;
+declare function modulesRegistryDest(cwd: string, packageId: string, version: string): string;
+//#endregion
+//#region src/modules/Registry/index.d.ts
+/** Aliases accepted by acceptance helpers. */
+declare const createRegistryHttpClient: typeof createRegistryClient;
+declare const createPackageRegistryClient: typeof createRegistryClient;
+declare const createPublishArchive: typeof buildPublishArchive;
+declare const packPublishArchive: typeof buildPublishArchive;
+declare const buildRegistryPublishZip: typeof buildPublishArchive;
+declare const compareSelfUpdate: typeof checkSelfUpdate;
+declare const runSelfUpdateCheck: typeof checkSelfUpdate;
+declare const fetchLatestCliVersion: typeof checkSelfUpdate;
+//#endregion
+//#region src/modules/Find/types.d.ts
+/** Offline find / reverse-index types. */
+declare const WORKSPACE_OWNER_KEY: ".";
+/** path → ordered owner keys (dependency packageKey or workspace `.`). */
+type ReverseIndex = Map<string, string[]>;
+type FindPathOptions = {
+  cwd?: string;
+  /** Query path (alias: `query`). */
+  path?: string;
+  query?: string;
+  /** Append origin (`--source`). */
+  source?: boolean;
+  showSource?: boolean;
+  /** Print why-chains (`--path`). */
+  why?: boolean;
+  showPath?: boolean;
+  pathDetail?: boolean;
+};
+type FindPathResult = {
+  ok: boolean;
+  exitCode: number;
+  text: string;
+  stderr: string;
+  owners?: string[];
+};
+//#endregion
+//#region src/modules/Find/buildReverseIndex.d.ts
+/** Stable owner key aligned with Deps inspect (`name` else `repo_url`). */
+declare function packageOwnerKey(dep: LockedDependency): string;
+/**
+ * Build reverse index: deployed path → ordered owner keys.
+ * Hash-map keys are primary; `deployed_files` / `local_deployed_files` are unioned.
+ * Owner order: lock dependency array order, then workspace local.
+ */
+declare function buildReverseIndex(document: LockfileDocument | Record<string, unknown>): ReverseIndex;
+declare const build_reverse_index: typeof buildReverseIndex;
+declare const buildFindReverseIndex: typeof buildReverseIndex;
+//#endregion
+//#region src/modules/Find/lookup.d.ts
+/**
+ * Normalize a find query: `\`→`/`, strip leading `/` and `./`.
+ */
+declare function normalizeFindPath(query: string): string;
+/**
+ * Lookup owners for a query path: exact match, else longest `/`-suffix directory prefix.
+ * Also treats a query that ends with `/` as a directory prefix over indexed entries (APM parity).
+ */
+declare function lookupInIndex(query: string, index: ReverseIndex | Map<string, string[]> | Record<string, string[]>): string[];
+declare const lookup: typeof lookupInIndex;
+declare const lookupFindPath: typeof lookupInIndex;
+declare const lookupReverseIndex: typeof lookupInIndex;
+//#endregion
+//#region src/modules/Find/format.d.ts
+/**
+ * Human owner label: workspace `.`; else `repo_url` if set, otherwise `name`.
+ */
+declare function formatFindOwnerLabel(owner: string | LockedDependency | Record<string, unknown>, dep?: LockedDependency | Record<string, unknown> | null): string;
+declare const ownerLabel: typeof formatFindOwnerLabel;
+declare const formatOwnerLabel: typeof formatFindOwnerLabel;
+declare const findOwnerLabel: typeof formatFindOwnerLabel;
+/**
+ * Origin fragment for `--source` (APM priority).
+ * Workspace owner → `.  (workspace)`.
+ */
+declare function formatFindOrigin(owner: string | LockedDependency | Record<string, unknown> | null | undefined, dep?: LockedDependency | Record<string, unknown> | null): string;
+declare const formatOrigin: typeof formatFindOrigin;
+declare const formatSourceOrigin: typeof formatFindOrigin;
+declare const _formatOrigin: typeof formatFindOrigin;
+//#endregion
+//#region src/modules/Find/findPath.d.ts
+/**
+ * Offline find orchestration: load lock → reverse index → lookup → format.
+ * Exits: 0 tracked, 1 unknown path, 2 missing/unreadable lock.
+ */
+declare function findPath(options?: FindPathOptions): FindPathResult;
+declare const runFind: typeof findPath;
+declare const findDeployedPath: typeof findPath;
+declare const runFindPath: typeof findPath;
+//#endregion
+//#region src/modules/View/types.d.ts
+type ViewPackageOptions = {
+  cwd?: string;
+  package?: string;
+  name?: string;
+  query?: string;
+};
+type ViewIdentity = {
+  name?: string;
+  repo_url?: string;
+};
+type ViewError = "no_lockfile" | "not_installed" | "ambiguous";
+type ViewPackageResult = {
+  ok: boolean;
+  exitCode: number;
+  text: string;
+  identity?: ViewIdentity;
+  /** Pin string: version → resolved_ref → resolved_tag → short commit. */
+  version?: string;
+  pin?: string;
+  modulesPath?: string;
+  summary?: string;
+  error?: ViewError;
+  query?: string;
+  matches?: Array<{
+    name?: string;
+    repo_url?: string;
+  }>;
+};
+//#endregion
+//#region src/modules/View/viewPackage.d.ts
+/**
+ * Offline local package view: lock resolve → modules path → optional summary.
+ * Honest exits: 0 success, 1 not_installed/ambiguous, 2 no_lockfile.
+ * No network / registry I/O.
+ */
+declare function viewPackage(options?: ViewPackageOptions): ViewPackageResult;
+declare const runView: typeof viewPackage;
+declare const viewLocalPackage: typeof viewPackage;
+declare const localView: typeof viewPackage;
+//#endregion
+//#region src/modules/Marketplace/errors.d.ts
+/** Marketplace-specific error hierarchy. */
+declare class MarketplaceError extends Error {
+  constructor(message: string);
+}
+declare class MarketplaceNotFoundError extends MarketplaceError {
+  readonly marketplaceName: string;
+  constructor(marketplaceName: string, host?: string);
+}
+declare class MarketplaceFetchError extends MarketplaceError {
+  readonly marketplaceName: string;
+  readonly reason: string;
+  constructor(marketplaceName: string, reason?: string);
+}
+declare class MarketplacePluginNotFoundError extends MarketplaceError {
+  readonly pluginName: string;
+  readonly marketplaceName: string;
+  constructor(pluginName: string, marketplaceName: string);
+}
+declare class MarketplaceUnsupportedSourceError extends MarketplaceError {
+  readonly pluginName: string;
+  readonly reason: string;
+  constructor(pluginName: string, reason: string);
+}
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/errors.d.ts
+/** Authoring schema / editor / detect / migrate errors. */
+declare class MarketplaceAuthoringError extends MarketplaceError {
+  readonly exitCode: number;
+  constructor(message: string, exitCode?: number);
+}
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/types.d.ts
+/** Marketplace authoring types (bapm.yml `marketplace:` block). Separate from consumer JSON models. */
+type MarketplaceAuthoringOwner = string | {
+  name: string;
+  url?: string;
+  email?: string;
+};
+type MarketplaceAuthoringBuild = {
+  tagPattern?: string;
+};
+type MarketplaceAuthoringOutputs = Record<string, unknown>;
+type PackageEntry = {
+  name: string;
+  source: string;
+  version?: string;
+  ref?: string;
+  subdir?: string;
+  tag_pattern?: string;
+  include_prerelease?: boolean;
+  description?: string;
+  homepage?: string;
+  tags?: string[];
+  author?: string | Record<string, string>;
+  license?: string;
+  repository?: string;
+  keywords?: string[];
+  category?: string;
+  /** Derived: source begins with `./`. */
+  isLocal: boolean;
+  /** Snake alias for APM parity. */
+  is_local: boolean;
+};
+type MarketplaceAuthoringConfig = {
+  name?: string;
+  description?: string;
+  version?: string;
+  owner?: MarketplaceAuthoringOwner;
+  sourceBase?: string;
+  build?: MarketplaceAuthoringBuild;
+  outputs?: MarketplaceAuthoringOutputs;
+  /** Legacy single-output / pass-through keys retained when present. */
+  output?: unknown;
+  claude?: unknown;
+  codex?: unknown;
+  metadata?: Record<string, unknown>;
+  versioning?: unknown;
+  packages: PackageEntry[];
+};
+type LoadMarketplaceFromBapmYmlOptions = {
+  cwd?: string;
+  path?: string;
+};
+type LoadMarketplaceResult = {
+  ok: true;
+  config: MarketplaceAuthoringConfig;
+  path: string;
+  source: "bapm.yml" | "marketplace.yml";
+};
+type DetectAuthoringConfigSourceOptions = {
+  cwd?: string;
+};
+type DetectAuthoringConfigSourceResult = {
+  kind: "bapm.yml";
+  ok: true;
+  path: string;
+} | {
+  kind: "marketplace.yml";
+  ok: true;
+  path: string;
+} | {
+  kind: "both";
+  ok: false;
+  error: string;
+} | {
+  kind: "none";
+  ok: false;
+  message: string;
+  error: string;
+};
+type AuthoringPackageEditOptions = {
+  cwd?: string;
+  path?: string;
+  name: string;
+  source?: string;
+  version?: string;
+  ref?: string;
+  subdir?: string;
+  tagPattern?: string;
+  tag_pattern?: string;
+  tags?: string[] | string;
+  includePrerelease?: boolean;
+  include_prerelease?: boolean;
+  description?: string;
+  category?: string;
+  /** Skip git ls-remote verify on add. */
+  noVerify?: boolean;
+};
+type AuthoringPackageRemoveOptions = {
+  cwd?: string;
+  path?: string;
+  name: string;
+};
+type EditorResult = {
+  ok: true;
+  path: string;
+} | {
+  ok: false;
+  error: string;
+};
+type CheckMarketplaceAuthoringOptions = {
+  cwd?: string;
+  path?: string;
+  offline?: boolean;
+  /** Injectable ls-remote for tests. */
+  lsRemote?: (repoUrl: string, ref?: string) => Promise<void> | void;
+};
+type CheckMarketplaceAuthoringResult = {
+  ok: boolean;
+  exitCode: number;
+  errors: string[];
+  warnings: string[];
+};
+type MigrateMarketplaceYmlOptions = {
+  cwd?: string;
+  dryRun?: boolean;
+  force?: boolean;
+  yes?: boolean;
+};
+type MigrateMarketplaceYmlResult = {
+  ok: boolean;
+  dryRun: boolean;
+  message?: string;
+  error?: string;
+};
+type RenderMarketplaceBlockOptions = {
+  owner?: string;
+  name?: string;
+  cwd?: string;
+};
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/source.d.ts
+type SourceValidationResult = {
+  ok: true;
+} | {
+  ok: false;
+  error: string;
+};
+/**
+ * Validate authoring package `source` (req-mf-017 / APM SOURCE_RE).
+ * Returns `{ ok }` shape (also usable as boolean via helpers).
+ */
+declare function validateMarketplaceAuthoringSource(source: string): SourceValidationResult;
+/** Boolean / throw-friendly alias. */
+declare function isValidMarketplaceAuthoringSource(source: string): boolean;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/load.d.ts
+/**
+ * Load marketplace authoring config from `bapm.yml` `marketplace:` block.
+ * Inherits top-level name/description/version when omitted in the block.
+ */
+declare function loadMarketplaceFromBapmYml(options?: LoadMarketplaceFromBapmYmlOptions): LoadMarketplaceResult;
+/** Load legacy standalone marketplace.yml (top-level marketplace keys). */
+declare function loadMarketplaceFromLegacyYml(options?: {
+  cwd?: string;
+  path?: string;
+}): LoadMarketplaceResult;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/detect.d.ts
+/**
+ * Detect authoring config source: preferred bapm.yml block / legacy / both / none.
+ */
+declare function detectAuthoringConfigSource(options?: DetectAuthoringConfigSourceOptions): DetectAuthoringConfigSourceResult;
+/**
+ * Smart loader: detect source, load, warn if legacy.
+ * Throws MarketplaceAuthoringError on both/none/validation.
+ */
+declare function loadMarketplaceAuthoringConfig(options?: {
+  cwd?: string;
+  warn?: (message: string) => void;
+}): LoadMarketplaceResult;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/initTemplate.d.ts
+/**
+ * Render a `marketplace:` YAML block template (~APM render_marketplace_block).
+ * Does not write host marketplace.json artifacts.
+ */
+declare function renderMarketplaceBlock(options?: RenderMarketplaceBlockOptions): string;
+/** Alias used by some call sites / acceptance soft-resolve. */
+declare const renderInitMarketplaceBlock: typeof renderMarketplaceBlock;
+declare const createMarketplaceAuthoringTemplate: typeof renderMarketplaceBlock;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/init.d.ts
+type InitMarketplaceAuthoringOptions = {
+  cwd?: string;
+  path?: string;
+  owner?: string;
+  name?: string;
+  force?: boolean;
+};
+type InitMarketplaceAuthoringResult = {
+  ok: true;
+  path: string;
+  createdManifest: boolean;
+} | {
+  ok: false;
+  error: string;
+};
+/**
+ * Scaffold or overwrite `marketplace:` in bapm.yml. Creates stub manifest if missing.
+ */
+declare function initMarketplaceAuthoring(options?: InitMarketplaceAuthoringOptions): InitMarketplaceAuthoringResult;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/editor.d.ts
+/**
+ * Add a package entry to bapm.yml marketplace.packages; re-validate after write.
+ */
+declare function addMarketplacePackage(options: AuthoringPackageEditOptions): EditorResult;
+/**
+ * Update fields on an existing package entry.
+ */
+declare function setMarketplacePackage(options: AuthoringPackageEditOptions): EditorResult;
+/**
+ * Remove a package entry by name.
+ */
+declare function removeMarketplacePackage(options: AuthoringPackageRemoveOptions): EditorResult;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/check.d.ts
+/**
+ * Authoring check: schema load; offline = no network; online probes for unlocked remotes.
+ * Generic hosts: fail-soft warning. Unlocked remotes with token: required probe.
+ */
+declare function checkMarketplaceAuthoring(options?: CheckMarketplaceAuthoringOptions): Promise<CheckMarketplaceAuthoringResult>;
+declare const checkAuthoringMarketplace: typeof checkMarketplaceAuthoring;
+declare const runMarketplaceAuthoringCheck: typeof checkMarketplaceAuthoring;
+//#endregion
+//#region src/modules/Marketplace/modules/Authoring/migrate.d.ts
+/**
+ * Fold legacy marketplace.yml into bapm.yml `marketplace:` block.
+ */
+declare function migrateMarketplaceYml(options?: MigrateMarketplaceYmlOptions): MigrateMarketplaceYmlResult;
+declare const migrateLegacyMarketplaceYml: typeof migrateMarketplaceYml;
+declare const runMarketplaceMigrate: typeof migrateMarketplaceYml;
+//#endregion
+//#region src/modules/Marketplace/types.d.ts
+/** Shared option bags for Marketplace public APIs. */
+type MarketplaceConfigOptions = {
+  /** Override config root (defaults to `~/.bapm`). */
+  configDir?: string;
+};
+type MarketplaceFetchOptions = MarketplaceConfigOptions & {
+  forceRefresh?: boolean;
+  /** Injectable HTTP transport (tests / custom clients). */
+  fetch?: typeof globalThis.fetch;
+};
+type MarketplaceSourceInit = {
+  name: string;
+  url?: string;
+  ref?: string;
+  path?: string;
+  owner?: string;
+  repo?: string;
+  host?: string;
+  branch?: string;
+};
+type MarketplaceSourceKind = "local" | "url" | "github" | "gitlab" | "ado" | "git";
+type ValidationResult = {
+  checkName: string;
+  passed: boolean;
+  warnings: string[];
+  errors: string[];
+};
+//#endregion
+//#region src/modules/Marketplace/paths.d.ts
+/** Resolve the bapm config root (`~/.bapm` or injectable override). */
+declare function getBapmConfigDir(opts?: MarketplaceConfigOptions): string;
+declare function marketplacesJsonPath(opts?: MarketplaceConfigOptions): string;
+declare function marketplaceCacheDir(opts?: MarketplaceConfigOptions): string;
+/** Ensure config root exists (mode 0o700 when newly created). */
+declare function ensureBapmConfigDir(opts?: MarketplaceConfigOptions): string;
+//#endregion
+//#region src/modules/Marketplace/models.d.ts
+/** True when url is an HTTPS hosted marketplace.json document. */
+declare function urlNamesRemoteManifest(url: string): boolean;
+type MarketplacePlugin = {
+  readonly name: string;
+  readonly source: unknown;
+  readonly description: string;
+  readonly version: string;
+  readonly tags: readonly string[];
+  readonly sourceMarketplace: string;
+  readonly registry: string;
+  readonly tagPattern: string | null;
+};
+type MarketplaceManifest = {
+  readonly name: string;
+  readonly plugins: readonly MarketplacePlugin[];
+  readonly ownerName: string;
+  readonly description: string;
+  readonly pluginRoot: string;
+  readonly sourceUrl: string;
+  readonly sourceDigest: string;
+  findPlugin(pluginName: string): MarketplacePlugin | undefined;
+  search(query: string): MarketplacePlugin[];
+};
+declare function createMarketplaceManifest(init: {
+  name: string;
+  plugins?: readonly MarketplacePlugin[];
+  ownerName?: string;
+  description?: string;
+  pluginRoot?: string;
+  sourceUrl?: string;
+  sourceDigest?: string;
+}): MarketplaceManifest;
+declare function createMarketplacePlugin(init: {
+  name: string;
+  source?: unknown;
+  description?: string;
+  version?: string;
+  tags?: readonly string[];
+  sourceMarketplace?: string;
+  registry?: string;
+  tagPattern?: string | null;
+}): MarketplacePlugin;
+declare class MarketplaceSource {
+  readonly name: string;
+  readonly url: string;
+  readonly ref: string;
+  readonly path: string;
+  readonly owner: string;
+  readonly repo: string;
+  readonly host: string;
+  readonly branch: string;
+  constructor(init: MarketplaceSourceInit);
+  get isRemoteManifestUrl(): boolean;
+  get kind(): MarketplaceSourceKind;
+  get localPath(): string;
+  get displaySource(): string;
+  toDict(): Record<string, unknown>;
+  static fromDict(data: Record<string, unknown>): MarketplaceSource;
+}
+/** Factory preferred by public API / soft-resolve helpers. */
+declare function createMarketplaceSource(init: MarketplaceSourceInit): MarketplaceSource;
+declare function resolveLocalFilesystemPath(source: MarketplaceSource): string;
+//#endregion
+//#region src/modules/Marketplace/hostClassify.d.ts
+/** Fine-grained marketplace host class for auth/API base selection. */
+type MarketplaceHostClass = ProviderHostClass;
+/**
+ * Classify a marketplace hostname using env allowlists.
+ * Throws on GHES↔GitLab overlap; ADO_HOST wins over GITHUB_HOST on same FQDN.
+ */
+declare function classifyMarketplaceHost(host: string, env?: NodeJS.ProcessEnv): MarketplaceHostClass;
+/** Map fine-grained class → MarketplaceSource.kind. */
+declare function marketplaceKindFromHostClass(cls: MarketplaceHostClass): MarketplaceSourceKind;
+/** Convenience: host → source kind (throws on overlap). */
+declare function classifyMarketplaceHostKind(host: string, env?: NodeJS.ProcessEnv): MarketplaceSourceKind;
+/** GitHub Contents API base for a github-class host. */
+declare function githubApiBaseForHost(host: string, env?: NodeJS.ProcessEnv): string;
+/** True when host is unlocked for marketplace fetch / authoring probe. */
+declare function isUnlockedMarketplaceHost(host: string, env?: NodeJS.ProcessEnv): boolean;
+//#endregion
+//#region src/modules/Marketplace/resolveToken.d.ts
+type ResolvedMarketplaceToken = {
+  /** Secret value — never log. */
+  readonly token: string;
+  /** Env source id for diagnostics (e.g. GITHUB_TOKEN). */
+  readonly source: string;
+};
+/**
+ * Resolve at most one env token for the host's class (or null).
+ * Fail-closed cross-class: never returns another class's env value.
+ */
+declare function resolveTokenForHost(host: string, env?: NodeJS.ProcessEnv): ResolvedMarketplaceToken | null;
+/** Alias preferred by some soft-resolve helpers. */
+declare const resolveMarketplaceTokenForHost: typeof resolveTokenForHost;
+declare const resolveAuthTokenForHost: typeof resolveTokenForHost;
+/** Auth headers for a given host class (empty when no token). */
+declare function authHeadersForHost(host: string, env?: NodeJS.ProcessEnv): Record<string, string>;
+//#endregion
+//#region src/modules/Marketplace/parse.d.ts
+/**
+ * Parse marketplace.json (string or object) into a MarketplaceManifest.
+ * Accepts Copilot (`repository`) and Claude (`source`) plugin shapes.
+ */
+declare function parseMarketplaceJson(input: string | object, sourceName?: string, opts?: {
+  sourceUrl?: string;
+  sourceDigest?: string;
+}): MarketplaceManifest;
+//#endregion
+//#region src/modules/Marketplace/registry.d.ts
+declare function listMarketplaces(opts?: MarketplaceConfigOptions): MarketplaceSource[];
+declare function getMarketplace(name: string, opts?: MarketplaceConfigOptions): MarketplaceSource;
+declare function addMarketplace(source: MarketplaceSource | Record<string, unknown>, opts?: MarketplaceConfigOptions): MarketplaceSource;
+declare function removeMarketplace(name: string, opts?: MarketplaceConfigOptions): void;
+//#endregion
+//#region src/modules/Marketplace/cache.d.ts
+declare const CACHE_TTL_SECONDS = 3600;
+declare function sanitizeCacheName(name: string): string;
+declare function cacheKeyForSource(source: MarketplaceSource): string;
+declare function readMarketplaceCache(key: string, opts?: MarketplaceConfigOptions): Record<string, unknown> | null;
+declare function writeMarketplaceCache(key: string, data: Record<string, unknown>, opts?: MarketplaceConfigOptions & {
+  indexDigest?: string;
+  etag?: string;
+  lastModified?: string;
+}): void;
+//#endregion
+//#region src/modules/Marketplace/fetch.d.ts
+declare const MAX_MARKETPLACE_JSON_BYTES: number;
+declare const MARKETPLACE_PATHS: readonly ["marketplace.json", ".github/plugin/marketplace.json", ".claude-plugin/marketplace.json"];
+/**
+ * Fetch and parse a marketplace manifest (github | gitlab | ado | url | local).
+ */
+declare function fetchMarketplace(source: MarketplaceSource | Record<string, unknown>, opts?: MarketplaceFetchOptions): Promise<MarketplaceManifest>;
+declare function clearMarketplaceCache(source: MarketplaceSource | Record<string, unknown>, opts?: MarketplaceConfigOptions): number;
+declare function autoDetectMarketplacePath(source: MarketplaceSource, opts?: MarketplaceFetchOptions): Promise<string>;
+//#endregion
+//#region src/modules/Marketplace/validate.d.ts
+/** Thin validate: schema (name+source) + case-insensitive duplicate names. */
+declare function validateMarketplace(manifest: MarketplaceManifest): ValidationResult[];
+//#endregion
+//#region src/modules/Marketplace/resolver.d.ts
+type ParsedMarketplaceRef = {
+  pluginName: string;
+  marketplaceName: string;
+  ref: string | null;
+};
+type MarketplaceProvenance = {
+  discovered_via: string;
+  marketplace_plugin_name: string;
+  source_url?: string;
+  source_digest?: string;
+};
+/** Concrete dependency declaration for Resolver/Install (string or object form). */
+type MarketplaceConcreteDep = string | {
+  path: string;
+} | {
+  git: string;
+  ref?: string;
+};
+type MarketplacePluginResolution = {
+  /** Canonical string or structured concrete dependency. */
+  dependency: MarketplaceConcreteDep;
+  /** Alias for soft-resolve helpers / APM parity. */
+  canonical: string | MarketplaceConcreteDep;
+  plugin: MarketplacePlugin;
+  source_url: string;
+  source_digest: string;
+  provenance(marketplaceName?: string, pluginName?: string): MarketplaceProvenance;
+};
+type ResolveMarketplacePluginOptions = MarketplaceFetchOptions & {
+  /** Alias accepted by acceptance helpers. */
+  marketplaceConfigDir?: string;
+};
+/**
+ * Parse `NAME@MARKETPLACE[#ref]`.
+ * Returns null when the specifier is not a marketplace ref.
+ * Throws when `#ref` contains semver-range characters.
+ */
+declare function parseMarketplaceRef(specifier: string): ParsedMarketplaceRef | null;
+/**
+ * Resolve a marketplace plugin via `~/.bapm` registry + fetch/cache → concrete dep.
+ */
+declare function resolveMarketplacePlugin(pluginName: string, marketplaceName: string, versionSpec?: string | null, opts?: ResolveMarketplacePluginOptions): Promise<MarketplacePluginResolution>;
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/errors.d.ts
+/** Marketplace pack-outputs / builder errors (fail-closed emit). */
+declare class MarketplacePackOutputsError extends MarketplaceError {
+  readonly exitCode: number;
+  constructor(message: string, exitCode?: number);
+}
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/types.d.ts
+/** Supported host marketplace output formats. */
+type MarketplaceOutputFormat = string;
+/** Package after ref resolution (local pass-through or remote sha). */
+type ResolvedPackage = {
+  name: string;
+  /** Repository path without host (`owner/repo`) or local `./…` source. */
+  sourceRepo: string;
+  /** Original authoring source string. */
+  source: string;
+  subdir?: string;
+  /** Concrete ref (tag / branch / sha short-name). */
+  ref?: string;
+  /** 40-char git SHA when remote. */
+  sha?: string;
+  requestedVersion?: string;
+  tags: string[];
+  isLocal: boolean;
+  isPrerelease: boolean;
+  host?: string;
+  sourceUrl?: string;
+  effectiveTagPattern?: string;
+  category?: string;
+  entry: PackageEntry;
+};
+type LsRemoteResult = {
+  sha: string;
+  /** Ref name that matched (e.g. `refs/tags/v1.0.0` stripped or as given). */
+  ref: string;
+};
+type LsRemoteFn = (repoUrl: string, ref?: string) => Promise<LsRemoteResult> | LsRemoteResult;
+type BuildMarketplaceOutputsOptions = {
+  cwd?: string;
+  /** Authoring config path override. */
+  path?: string;
+  /**
+   * CLI `--marketplace` filter:
+   * - `undefined` / `"all"` — all enabled outputs from config
+   * - `"none"` — skip emit
+   * - comma list or string[] — only named formats
+   */
+  marketplace?: string | string[];
+  /** CLI `--marketplace-path FORMAT=PATH` overrides. */
+  marketplacePaths?: Record<string, string> | Array<string | {
+    format: string;
+    path: string;
+  }>;
+  dryRun?: boolean;
+  offline?: boolean;
+  includePrerelease?: boolean;
+  /** Injectable ls-remote for tests. */
+  lsRemote?: LsRemoteFn;
+  /** Pre-loaded config (skips detect/load). */
+  config?: MarketplaceAuthoringConfig;
+  /** Registered host-owned marketplace output capabilities. */
+  marketplaceOutputs?: MarketplaceOutputRegistry;
+};
+type MarketplaceOutputWritten = {
+  format: MarketplaceOutputFormat;
+  path: string;
+  dryRun: boolean;
+};
+type BuildMarketplaceOutputsResult = {
+  ok: true;
+  success: true;
+  dryRun: boolean;
+  skipped: boolean;
+  packages: ResolvedPackage[];
+  resolved: ResolvedPackage[];
+  written: MarketplaceOutputWritten[];
+  warnings: string[];
+};
+type ResolveMarketplacePackagesOptions = {
+  cwd?: string;
+  path?: string;
+  offline?: boolean;
+  includePrerelease?: boolean;
+  lsRemote?: LsRemoteFn;
+  config?: MarketplaceAuthoringConfig;
+};
+type ResolveMarketplacePackagesResult = {
+  packages: ResolvedPackage[];
+  resolved: ResolvedPackage[];
+};
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/profiles.d.ts
+/** Ensure candidate resolves under project root (path jail). */
+declare function ensureMarketplacePathWithin(absolutePath: string, projectRoot: string): string;
+type ResolveEffectiveOutputPathOptions = {
+  cwd: string;
+  format: MarketplaceOutputFormat;
+  defaultOutput: string;
+  /** Explicit override path (CLI or caller). */
+  path?: string;
+  config?: MarketplaceAuthoringConfig;
+};
+/**
+ * Resolve effective output path with precedence:
+ * CLI override → outputs.<fmt>.path → profile default.
+ * Confined under project root.
+ */
+declare function resolveEffectiveOutputPath(options: ResolveEffectiveOutputPathOptions): string;
+/** Alias for acceptance soft-resolve. */
+declare const resolveMarketplaceOutputPath: typeof resolveEffectiveOutputPath;
+/**
+ * Formats enabled by authoring `outputs` map (and legacy top-level claude/codex keys).
+ */
+declare function formatsEnabledInConfig(config: MarketplaceAuthoringConfig, knownFormats: Iterable<string>): MarketplaceOutputFormat[];
+type ParseMarketplaceFilterResult = {
+  kind: "all";
+} | {
+  kind: "none";
+} | {
+  kind: "list";
+  formats: MarketplaceOutputFormat[];
+};
+/**
+ * Parse CLI `--marketplace` filter. Unknown format → hard error.
+ */
+declare function parseMarketplaceFilter(marketplace: string | string[] | undefined, knownFormats?: ReadonlySet<string>): ParseMarketplaceFilterResult;
+/** Intersect config-enabled formats with CLI filter. */
+declare function selectOutputFormats(config: MarketplaceAuthoringConfig, marketplace: string | string[] | undefined, knownFormats?: ReadonlySet<string>): MarketplaceOutputFormat[];
+declare function normalizeMarketplacePathOverrides(input: Record<string, string> | Array<string | {
+  format: string;
+  path: string;
+}> | undefined, knownFormats?: ReadonlySet<string>): Record<string, string>;
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/resolve.d.ts
+/**
+ * Resolve authoring packages → ResolvedPackage[] (local pass-through; github via ls-remote).
+ */
+declare function resolveMarketplacePackages(options?: ResolveMarketplacePackagesOptions): Promise<ResolveMarketplacePackagesResult>;
+/** Alias for acceptance soft-resolve. */
+declare const resolveAuthoringPackages: typeof resolveMarketplacePackages;
+declare const resolveMarketplacePackPackages: typeof resolveMarketplacePackages;
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/mappers.d.ts
+/** Serialize host-owned marketplace documents with stable formatting. */
+declare function serializeMarketplaceJson(doc: Record<string, unknown>): string;
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/write.d.ts
+/**
+ * Atomically write marketplace.json (temp + rename) and create parent dirs.
+ */
+declare function atomicWriteMarketplaceJson(absolutePath: string, contents: string): void;
+//#endregion
+//#region src/modules/Marketplace/modules/PackOutputs/build.d.ts
+/**
+ * Load authoring → resolve once → map → atomic multi-output write (or dry-run).
+ */
+declare function buildMarketplaceOutputs(options?: BuildMarketplaceOutputsOptions): Promise<BuildMarketplaceOutputsResult>;
+/** Aliases accepted by acceptance soft-resolve. */
+declare const emitMarketplacePackOutputs: typeof buildMarketplaceOutputs;
+declare const runMarketplaceBuilder: typeof buildMarketplaceOutputs;
+declare const writeMarketplacePackOutputs: typeof buildMarketplaceOutputs;
+/**
+ * Detect whether cwd has a loadable marketplace authoring block (no throw on none).
+ */
+declare function tryLoadMarketplaceAuthoring(cwd: string): MarketplaceAuthoringConfig | undefined;
+//#endregion
+//#region src/common/packageVersion.d.ts
+/**
+ * Runtime package version from `@b-apm/core` package.json (lockstep with CLI releases).
+ * Resolves both `src/app/` (tests/dev) and `dist/` (published) layouts.
+ */
+declare function getVersion(): string;
+//#endregion
+//#region src/app/publicApi.d.ts
+declare const BAPM_NAME = "bapm";
+//#endregion
+export { AGENT_PLUGIN_MANIFEST_SCHEMA_V1, APM_LOCAL_MANIFEST_FILE, APM_LOCK_FILE, APM_MANIFEST_FILE, APM_MODULES_DIR, APM_POLICY_FILE, type AgentPluginAuthor, type AgentPluginDeclaredPath, type AgentPluginDiagnostic, type AgentPluginManifest, type AgentPluginMcpServer, type AgentPluginSkill, AgentPluginsError, type AgentPluginsErrorCode, type AnnotatedTagCandidate, type ApplyMcpInventoryOptions, type AttributedPrimitive, type AuditCiCheck, type AuditCiCheckName, type AuditCiFormat, type AuditCiResult, type AuditCiStructuredReport, type AuditCiSummary, BAPM_LOCAL_MANIFEST_FILE, BAPM_LOCK_FILE, BAPM_MANIFEST_FILE, BAPM_NAME, BAPM_POLICY_FILE, type BakeMcpStringMapOptions, type BakeableMcpServer, type BapmDependency, type BapmManifest, type BuildGitChildEnvOptions, type BuildMarketplaceOutputsOptions, type BuildMarketplaceOutputsResult, type BuildPublishArchiveOptions, type BuildPublishArchiveResult, CACHE_TTL_SECONDS, CANONICAL_TARGET_TOKENS, CYCLONEDX_SPEC_VERSION, type CacheCleanOptions, type CacheCleanResult, type CacheInfoOptions, type CacheInfoResult, type CheckMarketplaceAuthoringResult, type CheckReleaseTagOptions, type CheckReleaseTagResult, type CheckSelfUpdateOptions, type CheckSelfUpdateResult, type ClassifiedDependency, type CollectMcpServersOptions, type CollectMcpServersResult, type CollectedMcpServer, type CompileAgentsMdOptions, type CompileAgentsMdResult, type CompileAttributionEntry, type CreateAgentPluginManifestOptions, type CreateMinimalManifestOptions, type CreatePluginJsonOptions, type CreateRegistryClientOptions, DEFAULT_LOCAL_ROOT, DEFAULT_PARALLEL_CHECKS, DEFAULT_PARALLEL_DOWNLOADS, DEFAULT_POLICY_PROVIDERS, DEPLOYED_HASH_ALGO, type DependencyEntry, type DependencyKind, type DependencyLists, type DeployedHashViolation, type DepsListResult, type DepsTreeResult, type DepsWhyError, type DepsWhyPackage, type DepsWhyPath, type DepsWhyPathNode, type DepsWhyResult, type DetectAuthoringConfigSourceResult, type DiscoverAgentPluginDeclaredPathsResult, type DiscoverAgentPluginMcpOptions, type DiscoverAgentPluginMcpResult, type DiscoverAgentPluginSkillsOptions, type DiscoverAgentPluginSkillsResult, type DiscoverLockfileOptions, type DiscoverManifestOptions, type DiscoverPolicyOptions, type DiscoverPrimitivesOptions, type DiscoveredLockfile, type DiscoveredManifest, type DiscoveredPolicy, type DoctorCheck, type DoctorResult, type DownloadArgs, type DownloadPackageSpec, type DownloadPackagesOptions, type Downloader, EXPERIMENTAL_REGISTRIES_ENV, type EditorResult, type EnforceFrozenOptions, type EvaluateExecutableTrustOptions, type EvaluatePolicyOptions, type EvaluatePolicyResult, type EvaluateRequiredPackagePresenceOptions, type EvaluateRequiredPackagePresenceResult, type ExecutableGrantEntry, type ExecutableGrantSurface, type ExecutableTrustDecision, type ExecutableTrustOutcome, type ExportSbomFailure, type ExportSbomOptions, type ExportSbomResult, type ExportSbomSuccess, type ExtractPackArchiveOptions, type ExtractPackArchiveResult, FIXED_EPOCH_TIMESTAMP, FORMAT_CYCLONEDX, FORMAT_SPDX, type FakeTag, type FetchWithRedirectAuthDropInit, type FindPathOptions, type FindPathResult, type GitRemote, type GrantSurfaceInput, IMPLEMENTATION_DEFAULT_HOST, InstallError, type InstallErrorCode, type InstallOptions, type InstallResult, type InventoryDep, KIND_EXPRESSION, KIND_ID, KIND_NAMED, type LicenseClass, type LicenseKind, type LoadAgentPluginManifestOptions, type LoadLockfileOptions, type LoadLockfileResult, type LoadManifestOptions, type LoadManifestResult, type LoadMarketplaceResult, type LoadPolicyOptions, type LoadPolicyResult, type LoadedAgentPluginManifest, type LockFilename, type LockedDependency, type LockfileDocument, LockfileError, type LockfileErrorCode, type LockfileInput, type LsRemoteFn, type LsRemoteResult, MARKETPLACE_PATHS, MAX_MARKETPLACE_JSON_BYTES, MAX_RESOLVE_DEPTH, MAX_SAFE_ENTRIES, MAX_SAFE_UNCOMPRESSED_BYTES, ManifestError, type ManifestErrorCode, type ManifestFilename, type ManifestWarning, type MarketplaceAuthoringConfig, MarketplaceAuthoringError, type MarketplaceConcreteDep, type MarketplaceConfigOptions, MarketplaceError, MarketplaceFetchError, type MarketplaceFetchOptions, type MarketplaceHostClass, type MarketplaceManifest, MarketplaceNotFoundError, type MarketplaceOutputFormat, type MarketplaceOutputWritten, MarketplacePackOutputsError, type MarketplacePlugin, MarketplacePluginNotFoundError, type MarketplacePluginResolution, type MarketplaceProvenance, MarketplaceSource, type MarketplaceSourceInit, type MarketplaceSourceKind, MarketplaceUnsupportedSourceError, McpEnvBakeError, type MigrateMarketplaceYmlResult, type ObjectDependency, type OrgExecutables, OutdatedError, type OutdatedErrorCode, type OutdatedResult, type OutdatedRow, PLATFORM_TOKEN_ENV_NAMES, POLICY_DISCOVERY_PROVIDERS, POLICY_EXTENDS_MAX_DEPTH, POLICY_PROVIDER_GITHUB_OWNER_DOTGITHUB, POLICY_PROVIDER_LOCAL, PackError, type PackErrorCode, type PackageEntry, type ParseExecutableGrantsOptions, type ParseMarketplaceFilterResult, type ParsePolicyResult, type ParsedMarketplaceRef, type PluginJsonAuthor, type PluginJsonDocument, type PolicyCandidate, type PolicyDependencies, type PolicyDependencyInput, type PolicyDocument, type PolicyEnforcement, PolicyError, type PolicyErrorCode, type PolicyExecutables, type PolicyGateOptions, type PolicyGateResult, type PolicyStatusOptions, type PolicyStatusOutcome, type PolicyStatusReport, type PolicyStatusRuleCounts, type PolicyViolation, type PolicyWarning, type PrimitiveConflictDiagnostic, type PrimitiveSource, type PrimitiveType, PrimitivesError, type PrimitivesErrorCode, type ProviderHostClass, PruneError, type PruneErrorCode, type PruneResult, type PurgeInstallPathArgs, type RegistryAliasEntry, type RegistryAliasMap, type RegistryClient, type RegistryEntry, RegistryError, type RegistryErrorCode, type RegistryHttpRequest, type RegistryHttpResponse, type RegistryHttpTransport, type RegistryVersionInfo, type RequiredPackagePresenceDiagnostic, type RequiredPackageTrustOutcome, type ResolveAndLockOptions, type ResolveAndLockResult, type ResolveCredentialsOptions, type ResolveDependencyGraphOptions, type ResolveEffectiveFrozenOptions, type ResolveEffectiveOutputPathOptions, type ResolveExecutableTrustOptions, type ResolveGraphResult, type ResolveMarketplacePackagesOptions, type ResolveMarketplacePackagesResult, type ResolveMarketplacePluginOptions, type ResolvePorts, type ResolvePrimitiveConflictsOptions, type ResolvePrimitiveConflictsResult, type ResolvedCredentials, type ResolvedDeployedFile, type ResolvedMarketplaceToken, type ResolvedNode, type ResolvedPackage, ResolverError, type ResolverErrorCode, type ReverseIndex, type RunAuditCiOptions, type RunDepsOptions, type RunDoctorOptions, type RunInstallOptions, type RunOutdatedOptions, type RunPackOptions, type RunPackResult, type RunPruneOptions, type RunUninstallOptions, type RunUpdateOptions, SPDX_VERSION, SUPPORTED_FORMATS, SafeExtractError, type SameCredentialHostClassOptions, type SaveUserExecutableGrantsOptions, type SbomFormat, type SourceValidationResult, TARGET_ALIAS_TOKENS, type TagLister, type TargetIntegrationMap, type TreeSha256Violation, UninstallError, type UninstallErrorCode, type UninstallResult, UpdateError, type UpdateErrorCode, type UpdatePlanEntry, type UpdateResult, type UserExecutableGrants, type UserExecutableStoreOptions, VENDOR_TARGET_RE, type ValidationResult, type ViewError, type ViewIdentity, type ViewPackageOptions, type ViewPackageResult, WORKSPACE_OWNER_KEY, type WriteAgentPluginManifestOptions, type WriteLockfileOptions, type WriteManifestOptions, type WritePluginJsonOptions, type WriteProducerManifestOptions, type WriteProducerManifestResult, type WrittenAgentPluginManifest, _formatOrigin, abbreviateSha, addMarketplace, addMarketplacePackage, applyDeployedHashesToLock, applyMcpInventoryToLock, assertExperimentalRegistriesEnabled, assertPolicyGateAllows, assertSafeZipCentralDirectory, atomicWriteMarketplaceJson, auditCi, authHeadersForHost, authHeadersForResolved, authHostClassOf, autoDetectMarketplacePath, bakeMcpServerMaps, bakeMcpStringMap, bakeMcpStringValue, buildAliasCredentialClassMap, buildFindReverseIndex, buildGitChildEnv, buildHardenedGitEnv, buildMarketplaceOutputs, buildPluginJson, buildPublishArchive, buildPurl, buildRegistryPublishZip, buildReverseIndex, build_reverse_index, cacheClean, cacheInfo, cacheKeyForSource, checkAuthoringMarketplace, checkDoctor, checkExecutableTrust, checkMarketplaceAuthoring, checkOutdated, checkRelease, checkReleaseTag, checkSelfUpdate, classifyDeclaredLicense, classifyDependencyRef, classifyExecutableTrust, classifyMarketplaceHost, classifyMarketplaceHostKind, classifyProviderHostClass, classifyRequiredPackagePresence, cleanModulesCache, cleanupOrphanDeployedFiles, clearMarketplaceCache, collectAdoHosts, collectDeployedHashViolations, collectDeployedHashes, collectLocalSourcePaths, collectMcpServers, collectTreeSha256Violations, compareSelfUpdate, compileAgentsMd, compileProject, componentName, componentVersion, computeCanonicalTreeSha256, createAgentPluginManifest, createDefaultDownloader, createDefaultGitRemote, createDefaultTagLister, createFetchTransport, createGitChildEnv, createMarketplaceAuthoringTemplate, createMarketplaceManifest, createMarketplacePlugin, createMarketplaceSource, createMinimalManifest, createMinimalManifestDocument, createPackageRegistryClient, createPeelAwareTagLister, createPluginJson, createPluginJsonDocument, createPublishArchive, createRegistryClient, createRegistryHttpClient, credentialHostClass, credentialHostClassForHost, credentialHostClassOf, credentialHostClassesEqual, declaredTargetIds, declaredTargetIntegrationMap, defaultPolicyProviders, depsList, depsTree, depsWhy, describeSecretRefuse, detectAuthoringConfigSource, digestsEqual, discoverAgentPluginDeclaredPaths, discoverAgentPluginMcp, discoverAgentPluginSkills, discoverLocalPolicyPath, discoverLockfilePath, discoverManifestPath, discoverPolicyPath, discoverPolicyProviders, discoverPolicyWithProviders, discoverPrimitives, doctor, downloadPackages, downloadUrl, effectiveLocalPath, effectiveProviderClassForHost, emitAgentsMd, emitManifest, emitMarketplacePackOutputs, emitPluginJson, enforceFrozen, ensureBapmConfigDir, ensureLocalRootUntracked, ensureLocalSourcesUntracked, ensureMarketplacePathWithin, evaluateExecutableTrust, evaluateInstallPolicy, evaluateMcpExecutableTrust, evaluatePolicy, evaluatePolicyRules, evaluateRequireLockPresence, evaluateRequiredPackagePresence, evaluateRequiredPackagesFromLock, experimentalRegistriesRemediation, exportSbom, extractPack, extractPackArchive, fetchAndMaterializeRegistry, fetchLatestCliVersion, fetchMarketplace, fetchRedirectAuthDrop, fetchWithCredentialHostClassRedirects, fetchWithRedirectAuthDrop, findDeployedPath, findLatestAnnotatedTag, findOwnerLabel, findPath, formatAuditCiJson, formatAuditCiSarif, formatFindOrigin, formatFindOwnerLabel, formatOrigin, formatOwnerLabel, formatSourceOrigin, formatTreeSha256Violation, formatUnsupportedMessage, formatsEnabledInConfig, gateExecutableMcp, getBapmConfigDir, getCacheInfo, getMarketplace, getVersion, gitChildEnvForHost, githubApiBaseForHost, hasGrantSurface, hashFileAt, hashFileBytes, hostClassForCredentials, hostClassForPolicy, hostClassOf, hostsShareCredentialClass, identityToCacheDir, initMarketplaceAuthoring, installProject, isCiEnvTruthy, isExemptInsecureHost, isExperimentalRegistriesEnabled, isFullRevisionPin, isGitSourcedLockEntry, isPolicyDisabled, isSecretPackPath, isSemanticallyEquivalent, isUnlockedMarketplaceHost, isValidMarketplaceAuthoringSource, isValidPluginName, isValidProjectName, isValidTargetToken, listDeps, listGitRemotes, listMarketplaces, loadAgentPluginManifest, loadBaseManifest, loadEffectiveManifest, loadExecutableUserGrants, loadLockfile, loadLockfileOrNull, loadManifest, loadMarketplaceAuthoringConfig, loadMarketplaceFromBapmYml, loadMarketplaceFromLegacyYml, loadPolicy, loadUserExecutableGrants, loadUserExecutables, loadYamlDocument, localRootGitignorePattern, localView, locateGitPackageTree, lookup, lookupFindPath, lookupInIndex, lookupReverseIndex, marketplaceCacheDir, marketplaceKindFromHostClass, marketplacesJsonPath, materializeRegistryArchive, materializeRegistryNodes, mayAttachGitCredential, mergeLocalOverlay, mergePolicies, mergePolicy, mergePolicyChain, mergePolicyDocuments, migrateLegacyMarketplaceYml, migrateMarketplaceYml, modulesCacheInfo, modulesRegistryDest, normalizeFindPath, normalizeFormat, normalizeMarketplacePathOverrides, normalizeRepoIdentity, outdated, ownerLabel, packArchive, packProject, packPublishArchive, packageBasenameFromRepo, packageOwnerKey, parseExecutableGrants, parseLocalOverlayDocument, parseLockfile, parseLockfileDocument, parseManifest, parseManifestDocument, parseMarketplaceFilter, parseMarketplaceJson, parseMarketplaceRef, parsePackageId, parsePolicy, parsePolicyDocument, parseZipCentralDirectory, persistUserExecutableGrant, pickHighestInIntersection, pickHighestSatisfyingTag, pickRegistryVersion, pickTightestRange, policyHostClass, prune, pruneModules, purgeModulesInstallPaths, readMarketplaceCache, readUserExecutableGrants, redactPolicyRef, redirectSafeFetch, registryRepoUrl, removeMarketplace, removeMarketplacePackage, renderInitMarketplaceBlock, renderMarketplaceBlock, repoBasename, repoOwnerRepo, resolveAndLock, resolveAuthCredentialsForHost, resolveAuthTokenForHost, resolveAuthoringPackages, resolveConflicts, resolveCredentialsForHost, resolveDependencyGraph, resolveEffectiveFrozen, resolveEffectiveOutputPath, resolveExecutableTrust, resolveExtends, resolveHostClass, resolveHostCredentials, resolveLocalFilesystemPath, resolveMarketplaceOutputPath, resolveMarketplacePackPackages, resolveMarketplacePackages, resolveMarketplacePlugin, resolveMarketplaceTokenForHost, resolvePackageQuery, resolvePolicyChain, resolvePolicyExtends, resolvePrimitiveConflicts, resolveProjectRemote, resolveRegistryBaseUrl, resolveRegistryToken, resolveTokenForHost, resolveUserConfigRoot, rewriteDownloadBase, runAudit, runAuditCi, runCheckRelease, runCompile, runDepsList, runDepsTree, runDepsWhy, runDoctor, runFind, runFindPath, runInstall, runMarketplaceAuthoringCheck, runMarketplaceBuilder, runMarketplaceMigrate, runOutdated, runPack, runPolicyDiscovery, runPolicyGate, runPolicyStatus, runPrune, runSelfUpdateCheck, runUninstall, runUpdate, runView, safeExtractZip, safeResolveUnderCwd, sameCredentialHostClass, sanitizeCacheName, saveExecutableUserGrants, saveUserExecutableGrants, saveUserExecutables, scrubUrl, selectGitRemoteForPolicy, selectOutputFormats, selectProjectRemote, selectProviderClassForHost, serializeAgentPluginManifest, serializeLockfile, serializeManifest, serializeMarketplaceJson, serializePluginJson, serializeSbom, setMarketplacePackage, sha256Digest, sha256Hex, summarizeChecks, toLockRepoUrl, toStructuredReport, treeDeps, treeSha256Equal, tryLoadMarketplaceAuthoring, uninstall, uninstallPackages, unpackArchive, updateProject, urlNamesRemoteManifest, userConfigJsonPath, userGrantsToSurface, validateAgentPluginManifest, validateManifestEnv, validateMarketplace, validateMarketplaceAuthoringSource, validatePluginName, validateProjectName, verifyArchiveDigest, verifyDeployedFileHashes, viewLocalPackage, viewPackage, whyDeps, writeAgentPluginManifest, writeLockfile, writeManifest, writeManifestValidated, writeMarketplaceCache, writeMarketplacePackOutputs, writePluginJson, writePluginJsonFile, writeProducerManifest, writeUserExecutableGrants };