mfeflow 0.5.0 → 0.6.0

package/dist/inspect.d.ts

@@ -1,5 +1,6 @@
 import { type Issue, type MfeManifest, type RegistryEntry } from '@mfeflow/contracts';
 import { type MfeflowProject } from '@mfeflow/core';
+import type { Io } from './io.js';
 export declare const ENVS: readonly ['dev', 'staging', 'prod'];
 export type Read<T> = {
     state: 'missing';
@@ -27,6 +28,8 @@ export interface AppView {
     present: boolean;
     pkg: PackageView | undefined;
     mfe: Read<MfeManifest>;
+    /** Path from the root of the app file that was read: `mfeflow.app.json`, or the old `mfe.json`. */
+    appFile: string;
 }
 export interface WorkspacePackage {
     dir: string;
@@ -39,16 +42,25 @@ export interface ProjectView {
     project: MfeflowProject;
     apps: AppView[];
     workspace: WorkspacePackage[];
+    /** A polyrepo shell only: remote name → manifest URL of its dev server, from the shell's dev config. */
+    devRemotes?: Record<string, string>;
     /** env → remote name → entry. Only remotes with a file in that env are listed. */
     registry: Record<string, Record<string, Read<RegistryEntry>>>;
     /** Folders under registry/envs that exist. */
     envDirs: string[];
+    /** Folders of the apps that still use the old `mfe.json` name. */
+    legacyAppFiles: string[];
 }
 export declare function readText(file: string): Promise<string | undefined>;
 /** Workspace folders for the simple globs pnpm projects use: `dir/*`, plain paths, and `!` exclusions. */
 export declare function expandGlobs(root: string, globs: readonly string[]): Promise<string[]>;
-/** Everything the checks read, loaded once. Throws the E102-E104 errors of `loadProject`. */
-export declare function inspectProject(root: string): Promise<ProjectView>;
+/** Prints the old app file name notice to stderr, at most once for each `io`, which is once per command. */
+export declare function noticeLegacyAppFiles(io: Pick<Io, 'stderr'>, legacy: readonly string[]): void;
+/**
+ * Everything the checks read, loaded once. Throws the E102-E104 errors of `loadProject`, and E122
+ * when an app has both app file names. With `io`, apps on the old name get one notice per command.
+ */
+export declare function inspectProject(root: string, io?: Pick<Io, 'stderr'>): Promise<ProjectView>;
 /**
  * The version of `name` an app uses: what is installed under node_modules (walking up from
  * the app to the project root, as Node does, never above it), else the version its package.json

package/dist/output.d.ts

@@ -44,19 +44,88 @@ interface WriteReport {
     /** Unified diff of every change. Only present for a dry run. */
     diff?: string;
 }
+/** One repo of a polyrepo `init`. */
+export interface RepoReport {
+    /** The folder inside `root`. */
+    name: string;
+    repo: 'platform' | 'shell' | 'remote';
+    root: string;
+    /** Files written in this repo, relative to it. */
+    written: string[];
+    installed: boolean;
+}
 export interface InitResult extends WriteReport {
     command: 'init';
     scope: string;
     apps: AppReport[];
+    /** Only for `--topology polyrepo`: the repos made, in the order they were written. */
+    repos?: RepoReport[];
+    next: string[];
+}
+export interface AdoptResult extends WriteReport {
+    command: 'adopt';
+    scope: string;
+    apps: AppReport[];
+    /** Parts of the existing config adopt read but did not carry over, each with the reason. */
+    notAdopted: {
+        dir: string;
+        file: string;
+        field: string;
+        reason: string;
+    }[];
+    /** The build config files adopt read and left exactly as they were. */
+    buildConfig: string[];
+    /** Lines to paste into the shared list of a build config. */
+    snippet: string;
     next: string[];
 }
 export interface AddResult extends WriteReport {
     command: 'add';
-    kind: 'remote' | 'shell' | 'feature' | 'env-key';
+    kind: 'remote' | 'shell' | 'feature' | 'env-key' | 'team-repo';
     /** What was added: an app name, or feature names. */
     added: string[];
     /** Features that were already part of the project. */
     skipped: string[];
+    /** `add team-repo` only: the new repo's folder, next to this one. */
+    created?: string;
+}
+export interface UpgradeFileReport {
+    path: string;
+    reason: 'edited' | 'untracked' | 'edited-by-cli' | 'skipped-feature' | 'symlink';
+    /** `accept`: written with the new version. `keep`: left, and remembered. `undecided`: left, and the run fails without a person to ask. */
+    decision: 'accept' | 'keep' | 'undecided';
+    /** Keys in your file that the new version lacks or has with another value; accepting drops them. */
+    lostKeys: string[];
+    /** The part of `lostKeys` that the new version has with another value. */
+    changedValues: string[];
+    /** Unified diff from your file to the new version. */
+    diff: string;
+}
+export interface UpgradeResult extends WriteReport {
+    command: 'upgrade';
+    from: string;
+    /** Where `from` was read: the `cli` field of mfeflow.json, or the shell's `@mfeflow/runtime` range. */
+    fromSource: 'mfeflow.json' | 'package.json';
+    to: string;
+    /** Nothing to write: the project already matches this version. */
+    upToDate: boolean;
+    /** Generated files you had not changed, now at the new version. */
+    replaced: string[];
+    created: string[];
+    /** package.json, pnpm-workspace.yaml and turbo.json, edited in place. */
+    edited: string[];
+    diverged: UpgradeFileReport[];
+    /** Registry features by name: `verified` against the recorded hash, `first-seen` when none was recorded, or `accepted-changed`. */
+    integrity: Record<string, 'verified' | 'first-seen' | 'accepted-changed'>;
+    /** Generated files you deleted. Not brought back. */
+    missing: string[];
+    /** Files the new version no longer generates. Left in place. */
+    removed: string[];
+    migrations: {
+        feature: string;
+        from: string;
+        to: string;
+    }[];
 }
 export interface FeatureInfo {
     /** `mfeflow` for the features that ship with the CLI, otherwise the registry's namespace, like `@test`. */
@@ -126,6 +195,8 @@ export interface ReportResult {
     summary: Summary;
     checks: CheckReport[];
     findings: Finding[];
+    /** `check-compat --against`: where the shell's versions came from. */
+    against?: string;
 }
 export interface ShellBudget {
     name: string;
@@ -144,7 +215,7 @@ export interface RouteBudget {
     expose: string | null;
     /** Entry plus the expose's synchronous JS, gzip KB. */
     kb: number;
-    /** mfe.json budgets.initialJsKb, or null. */
+    /** mfeflow.app.json budgets.initialJsKb, or null. */
     budgetKb: number | null;
     pass: boolean | null;
 }
@@ -227,6 +298,14 @@ export interface DeployResult {
     index?: RegistryIndex;
     warnings: string[];
     findings: Finding[];
+    /** Server mode only: set when the deploy started a percentage rollout. `version` is then the candidate. */
+    rollout?: {
+        id: string;
+        stable: string;
+        candidate: string;
+        percent: number;
+        steps: number[];
+    };
 }
 export interface StatusRemote {
     name: string;
@@ -239,6 +318,13 @@ export interface StatusRemote {
     /** Versions on the host newer than `version` that no environment points at; null when the host cannot list. */
     unreferenced: string[] | null;
     drift: string[];
+    /** Server mode with a token: the remote was killed and is not in the served index. */
+    killed?: boolean;
+    /** Server mode with a token: a percentage rollout is running. */
+    rollout?: {
+        candidate: string;
+        percent: number;
+    } | null;
 }
 export interface StatusEnv {
     env: string;
@@ -256,12 +342,61 @@ export interface StatusResult {
     envs: StatusEnv[];
     findings: Finding[];
 }
+/** `mfeflow rollout step|complete|abort`. Fields are null for a dry run, which sends nothing. */
+export interface RolloutCommandResult {
+    ok: boolean;
+    command: 'rollout';
+    action: 'step' | 'complete' | 'abort' | 'status';
+    dryRun: boolean;
+    root: string;
+    host: string;
+    env: string;
+    remote: string;
+    stable: string | null;
+    candidate: string | null;
+    percent: number | null;
+    /** What the index serves now. */
+    serves: string | null;
+    /** `rollout status` only: the browser reports behind the gate. */
+    report?: {
+        startedAt: string;
+        steps: number[];
+        candidateCounts: {
+            loads: number;
+            errors: number;
+            clients: number;
+        };
+        stableCounts: {
+            loads: number;
+            errors: number;
+            clients: number;
+        };
+        gate: {
+            verdict: 'wait' | 'ok' | 'halt';
+            reason: string | null;
+        };
+        reporterCapFull: boolean;
+    };
+}
+/** `mfeflow kill` and `mfeflow restore`. */
+export interface KillCommandResult {
+    ok: boolean;
+    command: 'kill' | 'restore';
+    dryRun: boolean;
+    root: string;
+    host: string;
+    env: string;
+    remote: string;
+    /** False when the remote was already in that state. Null for a dry run. */
+    changed: boolean | null;
+    killed: boolean | null;
+}
 export interface FailureResult {
     ok: false;
     error: ErrorReport;
     exitCode: number;
 }
-export type CliResult = InitResult | AddResult | FeaturesResult | RegistryResult | ReportResult | BudgetResult | DevResult | DeployResult | StatusResult | FailureResult;
+export type CliResult = InitResult | AdoptResult | AddResult | UpgradeResult | FeaturesResult | RegistryResult | ReportResult | BudgetResult | DevResult | DeployResult | StatusResult | RolloutCommandResult | KillCommandResult | FailureResult;
 /** The plan as plain data for `--json`, without file contents. Features are listed once. */
 export declare function planReport(plan: Plan): PlanReport;
 /** Checks a document the CLI printed with `--json`. Returns the problems; empty means valid. */

package/dist/pipeline.d.ts

@@ -1,8 +1,11 @@
 import { PlanBuilder, type MfeflowProject, type Plan } from '@mfeflow/core';
 /** Reads a project file by its `/`-separated path; undefined when it does not exist. */
 export declare function projectReader(root: string): (file: string) => Promise<string | undefined>;
-/** A plan builder that reads `root`, keeps dependency versions in the catalog and resolves `@mfeflow/*` ranges. */
-export declare function createBuilder(root: string, checkout: string | undefined): PlanBuilder;
+/**
+ * A plan builder that reads `root`, keeps dependency versions in the catalog and resolves `@mfeflow/*` ranges.
+ * `links` maps a package name to the `link:` path it is installed from instead of a registry range.
+ */
+export declare function createBuilder(root: string, checkout: string | undefined, links?: Readonly<Record<string, string>>): PlanBuilder;
 /** `plan` with the `mfeflow.json` change added, for the summary and the diff. */
 export declare function withProjectChange(plan: Plan, project: MfeflowProject): Plan;
 /**

package/dist/polyrepo.d.ts

@@ -0,0 +1,69 @@
+import { type LoadedFeature, type MfeflowProject, type Plan } from '@mfeflow/core';
+import type { Globals } from './args.js';
+import { type RemoteSpec } from './devremotes.js';
+import { type FeatureOptions } from './options.js';
+import type { PlanReport } from './output.js';
+import type { Runtime } from './runtime.js';
+import { type WriteOutcome } from './write.js';
+export declare const PLATFORM_DIR = "platform";
+export declare const SHELL_DIR = "shell";
+export type RepoKind = 'platform' | 'shell' | 'remote';
+export declare function assertFeaturesFit(features: readonly string[]): void;
+export interface RepoRequest {
+    kind: RepoKind;
+    /** The folder inside the org folder. */
+    dir: string;
+    root: string;
+    scope: string;
+    /** The GitHub owner the CI and Renovate files point at; the scope without `@` when empty. */
+    org?: string | undefined;
+    /** The remote this repo holds (kind remote only). */
+    remote?: RemoteSpec;
+    /** The remotes the shell routes to and lists in its dev config (kind shell only). */
+    shellRemotes?: readonly RemoteSpec[];
+    features: readonly string[];
+    featureOptions: FeatureOptions;
+    local: string | undefined;
+    cwd: string;
+}
+/** Where the shell and each remote install `<scope>/*` from until the platform packages are published. */
+export declare function platformLinks(scope: string): Record<string, string>;
+export declare function remotePorts(names: readonly string[]): RemoteSpec[];
+export declare function repoProject(kind: RepoKind, scope: string, remote?: RemoteSpec): MfeflowProject;
+/**
+ * `core` for one repo of a polyrepo: the same files and dependencies, minus what belongs to the
+ * monorepo as a whole. The root package.json is named after the repo, the README and AGENTS.md come
+ * from the polyrepo template, and a platform repo keeps only the workspace files.
+ */
+export declare function polyrepoCore(core: LoadedFeature, request: Pick<RepoRequest, 'kind' | 'scope' | 'remote'>): Promise<LoadedFeature>;
+export interface RepoPlan {
+    request: RepoRequest;
+    project: MfeflowProject;
+    plan: Plan;
+}
+/** What one repo of the polyrepo would get; nothing is written. */
+export declare function planRepo(rt: Runtime, request: RepoRequest): Promise<RepoPlan>;
+/** `report` with every path under `dir/`, so reports of several repos can share one list. */
+export declare function prefixReport(report: PlanReport, dir: string): PlanReport;
+export declare function mergeReports(reports: readonly PlanReport[]): PlanReport;
+export interface RepoWrite {
+    repo: RepoPlan;
+    outcome: WriteOutcome;
+}
+/** The folders of `dir`'s path that do not exist yet, outermost first. */
+export declare function missingParents(dir: string): Promise<string[]>;
+/** The warning for repos `git init` did not make, or nothing when all of them are. */
+export declare function notReposWarning(dirs: readonly string[]): string[];
+export interface RepoWrites {
+    writes: RepoWrite[];
+    /** Folders where `git init` did not run. */
+    notRepos: string[];
+}
+/**
+ * Writes the repos one after another, each in its own transaction with its own `git init`. If one
+ * fails, the repos this run already wrote are removed again, and so are the folders above them that
+ * this run made (while empty), so nothing half-built is left behind.
+ */
+export declare function writeRepos(rt: Runtime, globals: Globals, org: string, repos: readonly RepoPlan[]): Promise<RepoWrites>;
+/** The GitHub owner from `--org`, checked; undefined when not given. */
+export declare function checkOrg(org: string | undefined): string | undefined;

package/dist/publish.d.ts

@@ -17,10 +17,14 @@ export interface Session {
     secrets: string[];
     /** `--base-url`, else `registry.baseUrl` from mfeflow.json. */
     baseUrl: string | undefined;
+    /** Server mode with no host: there is nowhere to upload artifacts to. */
+    hostless: boolean;
 }
 export declare function envOf(args: Record<string, unknown>, key?: string): string;
 export declare function positionals(args: Record<string, unknown>, max: number, usage: string): string[];
-export declare function openSession(rt: Runtime, args: Record<string, unknown>, raw?: Globals): Promise<Session>;
+export declare function openSession(rt: Runtime, args: Record<string, unknown>, raw?: Globals, options?: {
+    hostOptional?: boolean;
+}): Promise<Session>;
 /**
  * A base URL ends up in a public index, so it must be an https URL (http only on localhost) with no
  * credentials, query or fragment. Returns the normalised form without a trailing slash.
@@ -86,4 +90,9 @@ export declare function commit(s: Session, options: CommitOptions): Promise<Comm
 /** The entry `registry/envs/<env>/<name>.json` records for what the index serves. */
 export declare function localEntryOf(remote: RegistryIndexRemote): RegistryEntry;
 export declare function writeLocalEntry(root: string, env: string, remote: RegistryIndexRemote): Promise<string>;
+export interface Build {
+    manifest: unknown;
+    files: Record<string, Uint8Array>;
+}
+export declare function readBuild(dir: string, shown: string): Promise<Build>;
 export {};

package/dist/runtime.d.ts

@@ -18,6 +18,8 @@ export interface Runtime {
     dev?: DevHost;
     /** `fetch` for S3 hosts. Tests stand in for the network. */
     hostFetch?: typeof fetch;
+    /** `fetch` for the registry server in server mode. Tests point it at a server on 127.0.0.1. */
+    serverFetch?: typeof fetch;
     /** Wraps the registry host `deploy`, `promote`, `rollback` and `status` open. Tests inject a second writer. */
     wrapHost?: (host: RegistryHost) => RegistryHost;
 }

package/dist/server-client.d.ts

@@ -0,0 +1,61 @@
+import { type RegistryIndex } from '@mfeflow/contracts';
+import { MfeflowError, type ErrorCode } from '@mfeflow/core';
+import type { Runtime } from './runtime.js';
+export declare const URL_ENV = "MFEFLOW_REGISTRY_URL";
+export declare const TOKEN_ENV = "MFEFLOW_REGISTRY_TOKEN";
+type Env = Readonly<Record<string, string | undefined>>;
+/** The server address: `--registry-url`, else `MFEFLOW_REGISTRY_URL`. Undefined means static mode. */
+export declare function serverUrlOf(args: Record<string, unknown>, env: Env): string | undefined;
+/**
+ * The address as the client uses it: https, or http on a loopback host, with no login, query or
+ * fragment, and no trailing slash. A token is sent to this address, so anything else is refused.
+ */
+export declare function normalizeServerUrl(raw: string): string;
+/** The catalogue code for a server error: its own code first, then the HTTP status. Always E5xx. */
+export declare function errorCodeFor(status: number, code: string | undefined): ErrorCode;
+export interface ServerFailure {
+    code: string;
+    message: string;
+    failures?: {
+        code: string;
+        message?: string;
+        route?: string;
+    }[];
+}
+export declare class ServerError extends Error {
+    readonly status: number;
+    readonly failure: ServerFailure;
+    constructor(status: number, failure: ServerFailure);
+}
+export interface Reply {
+    status: number;
+    body: unknown;
+}
+export declare class ServerClient {
+    readonly url: string;
+    private readonly token;
+    private readonly doFetch;
+    private readonly secrets;
+    constructor(url: string, token: string | undefined, doFetch: typeof fetch, secrets: readonly string[]);
+    /** How the server is named in output: never a credential. */
+    get label(): string;
+    /** Text the server sent, with the token taken out, for anything that is printed. */
+    scrub(words: string): string;
+    /** A result document with every string scrubbed. The server's words reach the output through it. */
+    scrubAll<T>(value: T): T;
+    get hasToken(): boolean;
+    /** Throws the catalogue error for anything that is not a 2xx reply; `gates_failed` is thrown as a ServerError. */
+    get(route: string, needsToken?: boolean): Promise<unknown>;
+    post(route: string, body: unknown): Promise<unknown>;
+    /** Like `get` but a 404 is `undefined`. */
+    getOptional(route: string): Promise<unknown>;
+    index(env: string): Promise<RegistryIndex | undefined>;
+    private send;
+    /** A server error as the catalogue error that names it, with secrets scrubbed. */
+    wrap(error: ServerError): MfeflowError;
+    /** Runs a call and turns every failure into a catalogue error, except `gates_failed`, which `onGates` handles. */
+    run<T>(work: () => Promise<T>, onGates?: (failure: ServerFailure) => T): Promise<T>;
+}
+/** The client, or undefined when this run is in static mode. */
+export declare function openServer(rt: Runtime, args: Record<string, unknown>): ServerClient | undefined;
+export {};

package/dist/system.d.ts

@@ -16,5 +16,7 @@ export interface System {
     install(root: string, packageManager: string, verbose: boolean): Promise<void>;
     /** `git init` unless `root` is already inside a work tree. Returns whether it ran. */
     gitInit(root: string): Promise<boolean>;
+    /** `git init` for a repo of its own, even when `root` sits inside another work tree. Returns whether it ran. */
+    initRepo(root: string): Promise<boolean>;
 }
 export declare function createSystem(io: Pick<Io, 'stderr'>, runner?: Run): System;

package/dist/testing.d.ts

@@ -3,7 +3,7 @@ import type { Io } from './io.js';
 import type { DevHost, DevProcess, DevSpec, WaitPolicy } from './proc.js';
 import type { Prompter } from './prompter.js';
 import type { Runtime } from './runtime.js';
-import type { System } from './system.js';
+import { type Run, type System } from './system.js';
 /** The checkout this package lives in; `--local` tests point at it. */
 export declare const REPO: string;
 export interface Recorded {
@@ -22,6 +22,7 @@ export interface SystemCalls {
         verbose: boolean;
     }[];
     gitInits: string[];
+    repoInits: string[];
 }
 export declare function fakeSystem(options?: {
     installError?: Error;
@@ -64,3 +65,18 @@ export declare function readTree(dir: string): Promise<Record<string, string>>;
 export declare function failure(promise: Promise<unknown>): Promise<MfeflowError>;
 /** Calls `fn`, which must throw an MfeflowError, and returns it. */
 export declare function thrown(fn: () => unknown): MfeflowError;
+/** Where git is installed, from a fixed list of system folders, never from a PATH search. */
+export declare function gitBinary(): string;
+/**
+ * The environment git runs in: no `GIT_*` variable, so git works on the folder it is run in and
+ * nothing else, and a PATH of git's own folder only.
+ */
+export declare function cleanGitEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Runs git with a clean environment in `cwd`; returns what it printed. */
+export declare function git(cwd: string, ...args: string[]): string;
+/** A `Run` that runs git by its fixed path in a clean environment, and refuses any other program. */
+export declare const gitRunner: Run;
+/** A system that runs the real `git init` (with a clean environment) and no install. */
+export declare function gitSystem(): System & SystemCalls;
+/** `file` with forward slashes, the way git prints a path on every OS. */
+export declare function posixPath(file: string): string;

package/dist/upgrade.d.ts

@@ -0,0 +1,25 @@
+import { type MfeflowProject, type UpgradeDecisions, type UpgradePlan } from '@mfeflow/core';
+import type { AssetRoots } from './assets.js';
+import type { FetchLike } from '@mfeflow/core';
+export interface UpgradeContext {
+    roots: AssetRoots;
+    fetch: FetchLike;
+    /** Registry namespaces the user trusts to be on loopback or private addresses. */
+    trusted?: ReadonlySet<string>;
+    /** Take registry content that differs from the hash recorded in mfeflow.json: every feature (`true`) or the named ones. */
+    acceptChanged?: boolean | ReadonlySet<string>;
+}
+/** How a registry feature's content compared with the hash recorded for it. */
+export type IntegrityState = 'verified' | 'first-seen' | 'accepted-changed';
+export interface ProjectUpgrade extends UpgradePlan {
+    /** Registry features by name. `first-seen`: no hash was recorded, so the served content could not be checked. */
+    integrity: Record<string, IntegrityState>;
+}
+/** The features `init` would apply for these recorded ones, in its order, `core` and `tsconfig` first. */
+export declare function replayOrder(project: MfeflowProject): string[];
+/**
+ * Plans moving the project at `root` to `toVersion` (default: this CLI) from the templates and
+ * features this CLI ships. A recorded feature that cannot be loaded, or that a registry serves at
+ * another version than the one installed, is left out and named in the plan's warnings.
+ */
+export declare function planProjectUpgrade(ctx: UpgradeContext, root: string, project: MfeflowProject, toVersion?: string, decisions?: UpgradeDecisions): Promise<ProjectUpgrade>;

package/dist/write.d.ts

@@ -10,6 +10,14 @@ export interface WriteRequest {
     project: MfeflowProject;
     /** Runs once the files are written, before the install (`git init` for hooks that need a repo). */
     afterWrite?: () => Promise<void>;
+    /** Install even when the plan adds no dependency, for a plan that moves ranges. */
+    install?: boolean;
+    /** Take `project` as it is: its `cli` is the version being upgraded to, not the one running. */
+    exactProject?: boolean;
+    /** Refuse to write through any symlink on a file's path, checked when the files are written. */
+    refuseSymlinks?: boolean;
+    /** The caller prints the summary and diff itself. */
+    quiet?: boolean;
 }
 export interface WriteOutcome {
     dryRun: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mfeflow",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Create and grow a React micro-frontend platform: mfeflow init, add remote, add <feature>.",
   "keywords": [
     "micro-frontend",
@@ -49,15 +49,15 @@
   },
   "dependencies": {
     "@clack/prompts": "1.8.1",
-    "@mfeflow/contracts": "0.5.0",
-    "@mfeflow/core": "0.5.0",
-    "@mfeflow/registry": "0.5.0",
+    "@mfeflow/contracts": "0.6.0",
+    "@mfeflow/core": "0.6.0",
+    "@mfeflow/registry": "0.6.0",
     "citty": "0.2.2",
     "semver": "7.8.5",
     "yaml": "2.9.1"
   },
   "devDependencies": {
-    "@mfeflow/rsbuild": "0.5.0",
+    "@mfeflow/rsbuild": "0.6.0",
     "@rslib/core": "1.0.5",
     "@types/node": "26.6.6",
     "@types/semver": "7.8.0",