@mfeflow/core 0.5.0 → 0.6.0

package/dist/adopt/detect.d.ts

@@ -0,0 +1,11 @@
+import type { DetectFederationOptions, FederationReport } from './types.js';
+/**
+ * Works out the Module Federation setup of an existing project by reading
+ * its config files as source. Config files are parsed, never imported or run:
+ * only literal values (and `const` names in the same file) are trusted, and
+ * everything else is listed in `notAdopted` with the reason.
+ *
+ * Apps are the folder itself plus each workspace package from
+ * `pnpm-workspace.yaml` or package.json `workspaces`.
+ */
+export declare function detectFederation(dir: string, options?: DetectFederationOptions): Promise<FederationReport>;

package/dist/adopt/disk.d.ts

@@ -0,0 +1,20 @@
+import type { ReadFile } from '../plan.js';
+/** Largest file the detector will read. A config this big is not a config. */
+export declare const MAX_FILE_BYTES = 1000000;
+/** A path the detector refused to read, and why. `file` is relative to the scanned folder. */
+export interface Refusal {
+    file: string;
+    reason: string;
+}
+/** Whether `target` is `root` or something under it. Compares whole segments, so `..x` is inside. */
+export declare function isInside(root: string, target: string): boolean;
+/**
+ * Reads from the disk without leaving `root`: every path is resolved through
+ * symlinks first and must still be inside the (resolved) root and outside
+ * node_modules. Anything refused or unreadable is recorded in `refused`
+ * instead of throwing.
+ */
+export declare function guardedDisk(root: string, refused: Refusal[]): {
+    read: ReadFile;
+    listDirs: (dir: string) => Promise<string[]>;
+};

package/dist/adopt/evaluate.d.ts

@@ -0,0 +1,70 @@
+import { type File, type Node, type ObjectExpression } from '@babel/types';
+/** A value written out in full in the source: what the detector is allowed to trust. */
+export type Value = string | number | boolean | null | Value[] | {
+    [key: string]: Value;
+};
+export type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare const ok: <T>(value: T) => Result<T>;
+export declare const fail: <T = never>(reason: string) => Result<T>;
+/** What a top-level name in a file is bound to. */
+export type Binding = {
+    kind: 'const';
+    init: Node;
+} | {
+    kind: 'import';
+    source: string;
+    imported: string;
+    depth?: number;
+} | {
+    kind: 'other';
+    what: string;
+};
+/** The top-level names and exports of one parsed file. */
+export interface Scope {
+    /** Absolute path of the file. */
+    file: string;
+    bindings: Map<string, Binding>;
+    /** Names whose value is changed after it is declared (`x.y = …`, `Object.assign(x, …)`). */
+    mutated: Set<string>;
+    /** Exported name (`default` for the default export) to the exported expression. */
+    exports: Map<string, Node>;
+    /** Exported name to the local const it was exported from, when there is one. */
+    exportedFrom: Map<string, string>;
+}
+/** Strips `as`, `satisfies`, `!` and `<T>x` so only the value is left. */
+export declare function unwrap(node: Node | null | undefined): Node | undefined;
+/** Reads the top-level bindings and exports of a parsed file. */
+export declare function scopeOf(ast: File, file: string): Scope;
+/** `process.env.X`, `process.env['X']` or `import.meta.env.X` under `node`, as text. */
+export declare function envAccess(node: Node): string | undefined;
+/** Why `node` is not a literal value, in plain words. */
+export declare function reasonFor(node: Node): string;
+/**
+ * Follows `const` names in the same file to the expression they hold, so a
+ * caller can look at its shape. Stops at anything that is not a plain const.
+ */
+export declare function resolveNode(node: Node | null | undefined, scope: Scope, seen?: ReadonlySet<string>): Result<Node>;
+export interface Entry {
+    key: string;
+    value: Node;
+}
+/**
+ * The properties of an object literal, with spreads of same-file const
+ * objects folded in. Anything that cannot be read is a problem, keyed by the
+ * property it belongs to when there is one.
+ */
+export declare function entriesOf(object: ObjectExpression, scope: Scope, seen?: ReadonlySet<string>): {
+    entries: Entry[];
+    problems: {
+        key?: string;
+        reason: string;
+    }[];
+};
+/** The literal value of `node`, or why it has none. Only same-file `const` names are followed. */
+export declare function evaluate(node: Node | null | undefined, scope: Scope, seen?: ReadonlySet<string>): Result<Value>;

package/dist/adopt/federation.d.ts

@@ -0,0 +1,20 @@
+import type { ObjectExpression } from '@babel/types';
+import { type Result, type Scope } from './evaluate.js';
+import type { DetectedRemote, DetectedShared } from './types.js';
+/** What the federation options say, minus the parts that could not be read. */
+export interface FederationOptions {
+    name?: string;
+    remotes: Record<string, DetectedRemote>;
+    exposes: Record<string, string>;
+    shared: Record<string, DetectedShared>;
+    /** Whether the options expose anything, counting entries that could not be read. */
+    exposing: boolean;
+}
+/** Records a part that was not read: `field` is a dotted path, `reason` plain words. */
+export type Report = (field: string, reason: string) => void;
+/** `shared.react`, or `shared['react-dom']` when the key is not a plain name. */
+export declare const fieldOf: (base: string, key: string) => string;
+/** `name@https://…/mf-manifest.json` or a bare URL, split into its parts. */
+export declare function parseRemote(value: string): Result<DetectedRemote>;
+/** Reads the fields adopt needs out of a federation options object literal. */
+export declare function readFederationOptions(options: ObjectExpression, scope: Scope, report: Report): FederationOptions;

package/dist/adopt/index.d.ts

@@ -0,0 +1,4 @@
+export { detectFederation } from './detect.js';
+export { planAdoption } from './plan.js';
+export type { AdoptAppFile, AdoptInput, AdoptPlan, AdoptRemote } from './plan.js';
+export type { BuildTool, DetectedApp, DetectedRemote, DetectedShared, DetectFederationOptions, FederationReport, FederationRole, NotAdopted, } from './types.js';

package/dist/adopt/plan.d.ts

@@ -0,0 +1,39 @@
+import { type MfeflowProject } from '@mfeflow/contracts';
+import type { FederationReport, NotAdopted } from './types.js';
+export interface AdoptInput {
+    report: FederationReport;
+    scope: string;
+    packageManager: MfeflowProject['packageManager'];
+}
+/** One `mfeflow.app.json` adopt will write, as plain data. */
+export interface AdoptAppFile {
+    name: string;
+    /** Folder of the app, relative to the project, `/` separated. `.` for the project itself. */
+    dir: string;
+    role: 'shell' | 'remote';
+    content: Record<string, unknown>;
+}
+/** A remote that gets `registry/envs/<env>/<name>.json`. */
+export interface AdoptRemote {
+    name: string;
+    port: number;
+}
+export interface AdoptPlan {
+    /** The `mfeflow.json` content, before the CLI stamps its version. */
+    project: MfeflowProject;
+    appFiles: AdoptAppFile[];
+    remotes: AdoptRemote[];
+    /** Folders of the shells; `@mfeflow/runtime` goes into each package.json. */
+    shellDirs: string[];
+    /** What the detector skipped plus what adopt itself could not carry, each with a reason. */
+    notAdopted: NotAdopted[];
+    /** Things the person should look at, in plain words. */
+    warnings: string[];
+}
+export declare const printable: (text: string) => string;
+/**
+ * Turns what {@link detectFederation} found into the files adopt writes, as data. Needs a
+ * shell: without one the project file would not validate, and a lone remote belongs to a
+ * multi-repo setup this release does not write.
+ */
+export declare function planAdoption(input: AdoptInput): AdoptPlan;

package/dist/adopt/types.d.ts

@@ -0,0 +1,73 @@
+import type { ReadFile } from '../plan.js';
+/** The bundler an adopted app builds with, judged from its config file name. */
+export type BuildTool = 'rsbuild' | 'rspack' | 'webpack';
+/** `remote` when the app exposes modules, `shell` (a host) when it only consumes them. */
+export type FederationRole = 'shell' | 'remote';
+/** A remote an app loads, as written in its `remotes`. */
+export interface DetectedRemote {
+    /** The remote's federation name: the part before `@` in `name@url`. Absent for a bare URL. */
+    name?: string;
+    /** The URL after `@`, or the whole string for a bare URL. */
+    entry: string;
+    /** `manifest` for an `mf-manifest.json` style entry, `script` for a `remoteEntry.js`. */
+    type: 'manifest' | 'script';
+}
+/** One shared package, with the two settings adopt carries over. */
+export interface DetectedShared {
+    singleton?: boolean;
+    /** A semver range, or `false` to turn the version check off. */
+    requiredVersion?: string | false;
+}
+/** One app with a Module Federation config, as far as it could be read without running it. */
+export interface DetectedApp {
+    /** Folder of the app relative to the scanned folder, with `/` separators. `.` for the folder itself. */
+    dir: string;
+    /** The federation `name`, when it is a literal. */
+    name?: string;
+    /** The `name` in the app's package.json, when there is one. */
+    packageName?: string;
+    role: FederationRole;
+    buildTool: BuildTool;
+    /** The build config, relative to the scanned folder. */
+    configFile: string;
+    /** The file the federation options were read from, when it is not `configFile`. */
+    federationFile?: string;
+    /** Remote alias (the key in `remotes`) to where it loads from. */
+    remotes: Record<string, DetectedRemote>;
+    /** Expose key (`./Button`) to the module path it points at. */
+    exposes: Record<string, string>;
+    shared: Record<string, DetectedShared>;
+    /** The dev server port, when it is a literal number. */
+    port?: number;
+}
+/** A part of a config the detector would not read, and why. Nothing here is guessed. */
+export interface NotAdopted {
+    /** The app folder, as in {@link DetectedApp.dir}. */
+    dir: string;
+    /** The file the part is in, relative to the scanned folder. */
+    file: string;
+    /** Where in the config: `remotes`, `shared.react.requiredVersion`, `port`, `options`, … */
+    field: string;
+    /** Plain words, e.g. "comes from a function call (getRemotes())". */
+    reason: string;
+}
+export interface FederationReport {
+    apps: DetectedApp[];
+    notAdopted: NotAdopted[];
+}
+export interface DetectFederationOptions {
+    /**
+     * Reads a file by absolute path; undefined when it does not exist. Defaults
+     * to a reader that stays inside the folder. A custom reader replaces that
+     * guard and gets only the lexical checks (imports that leave the folder or
+     * enter node_modules are refused by path), so custom readers must enforce
+     * containment, symlinks and size themselves.
+     */
+    read?: ReadFile;
+    /**
+     * Names of the sub-folders of an absolute path, used to expand workspace
+     * globs; an empty list when the folder does not exist. Defaults to the disk.
+     * Like `read`, a custom one must enforce containment and symlinks itself.
+     */
+    listDirs?: (dir: string) => Promise<string[]>;
+}

package/dist/adopt/workspace.d.ts

@@ -0,0 +1,16 @@
+import type { ReadFile } from '../plan.js';
+/** Folders never searched for apps: dependencies, build output, caches, VCS. */
+export declare const SKIPPED_DIRS: Set<string>;
+export interface WorkspaceProblem {
+    file: string;
+    reason: string;
+}
+/** A whole-path glob (`apps/**`, `packages/*-legacy`) as a regular expression. */
+export declare function globToRegExp(pattern: string): RegExp;
+/** Runs `fn` on each item one after the other, so a big folder tree never opens thousands of files at once. */
+export declare function eachInSequence<T>(items: readonly T[], fn: (item: T) => Promise<void>): Promise<void>;
+/**
+ * The folders that may hold an app, relative to `root` with `/` separators,
+ * sorted: the root itself plus every workspace package with a package.json.
+ */
+export declare function findAppDirs(root: string, read: ReadFile, listDirs: (dir: string) => Promise<string[]>, problems?: WorkspaceProblem[]): Promise<string[]>;

package/dist/app-file.d.ts

@@ -0,0 +1,20 @@
+import { type FsOps } from './fs.js';
+/** The ownership file in each app's folder. */
+export declare const APP_FILE = "mfeflow.app.json";
+/** The name the app file had before 0.6. Still read, with a notice. */
+export declare const LEGACY_APP_FILE = "mfe.json";
+export type AppFileName = typeof APP_FILE | typeof LEGACY_APP_FILE;
+export interface AppFileText {
+    /** Which of the two names was found. */
+    name: AppFileName;
+    text: string;
+    /** True when only the old name exists. */
+    legacy: boolean;
+}
+/**
+ * The text of the app file in `dir`: `mfeflow.app.json`, else the old `mfe.json`, else undefined.
+ * Throws E122 when both exist, because mfeflow cannot tell which one the team meant.
+ */
+export declare function readAppFile(dir: string, ops?: FsOps): Promise<AppFileText | undefined>;
+/** The one-line deprecation notice for apps that still use the old name, given their folders. */
+export declare function legacyAppFileNotice(folders: readonly string[]): string;

package/dist/apply.d.ts

@@ -15,6 +15,8 @@ export interface ApplyOptions {
     fs?: FsOps;
     /** Check the plan against the files and stop before writing anything. */
     dryRun?: boolean;
+    /** Refuse any write through a symlink, first-party included. Third-party changes always are. */
+    refuseSymlinks?: boolean;
 }
 export interface ApplyResult {
     written: string[];

package/dist/errors.d.ts

@@ -1,6 +1,7 @@
 /**
  * Every error the engine throws. Ranges: E1xx project and config, E2xx
- * features, E3xx build and runtime, E4xx feature registries, E5xx deploy and the static registry.
+ * features, E3xx build and runtime, E4xx feature registries, E5xx deploy and the static registry,
+ * E6xx upgrade.
  */
 export declare const ERROR_CATALOGUE: {
     readonly E101: {
@@ -52,8 +53,8 @@ export declare const ERROR_CATALOGUE: {
         readonly fix: 'Restore the folder, or remove the app from "apps" in mfeflow.json.';
     };
     readonly E113: {
-        readonly title: 'mfe.json is missing or invalid';
-        readonly fix: "Give the app a valid mfe.json (name, owner, shells, routes, exposes). The schema is at https://mfeflow.github.io/mfeflow/schema/mfe.json.";
+        readonly title: 'mfeflow.app.json is missing or invalid';
+        readonly fix: "Give the app a valid mfeflow.app.json (name, owner, shells, routes, exposes). The schema is at https://mfeflow.github.io/mfeflow/schema/mfeflow-app.json.";
     };
     readonly E114: {
         readonly title: 'A registry entry is missing or invalid';
@@ -64,8 +65,8 @@ export declare const ERROR_CATALOGUE: {
         readonly fix: 'Give one of them another port in its rsbuild config and in "apps" in mfeflow.json.';
     };
     readonly E116: {
-        readonly title: 'Two remotes claim routes that overlap, or an mfe.json disagrees with mfeflow.json';
-        readonly fix: 'Give each route to one remote (a wildcard such as /checkout/* also covers /checkout/pay), and keep the name in mfe.json equal to the app name.';
+        readonly title: 'Two remotes claim routes that overlap, or an app file disagrees with mfeflow.json';
+        readonly fix: 'Give each route to one remote (a wildcard such as /checkout/* also covers /checkout/pay), and keep the name in mfeflow.app.json equal to the app name.';
     };
     readonly E117: {
         readonly title: 'A copied file changed since mfeflow wrote it';
@@ -87,6 +88,18 @@ export declare const ERROR_CATALOGUE: {
         readonly title: 'A server env key is not listed in turbo.json';
         readonly fix: 'Add the key to "globalEnv" in turbo.json. Turborepo hides unlisted variables from tasks and replays a cached build without running env.ts, so a missing value would not fail the build.';
     };
+    readonly E122: {
+        readonly title: 'An app has both mfeflow.app.json and the old mfe.json';
+        readonly fix: "Keep mfeflow.app.json and delete mfe.json. Move any field you still need into mfeflow.app.json first. See https://mfeflow.github.io/mfeflow/reference/mfeflow-app-json.";
+    };
+    readonly E123: {
+        readonly title: 'This folder already has an mfeflow.json';
+        readonly fix: 'adopt only starts a project file; it never changes one. Use `mfeflow add` or `mfeflow upgrade` on this project, or run adopt in a folder that has no mfeflow.json.';
+    };
+    readonly E124: {
+        readonly title: 'adopt found nothing it can set up';
+        readonly fix: 'adopt needs a Module Federation host (shell) it can read, and a literal `name` for each app. Run it in the folder that holds the shell, or a workspace root that contains it, and read `mfeflow adopt --dry-run` for what was skipped.';
+    };
     readonly E201: {
         readonly title: 'Feature not found';
         readonly fix: 'List what is available with `mfeflow features`, or check the spelling.';
@@ -153,7 +166,7 @@ export declare const ERROR_CATALOGUE: {
     };
     readonly E302: {
         readonly title: 'A remote is not compatible with its shell';
-        readonly fix: 'Align the remote and the shell on the same major of the package, or update the "platform" range in the remote\'s mfe.json.';
+        readonly fix: 'Align the remote and the shell on the same major of the package, or update the "platform" range in the remote\'s mfeflow.app.json.';
     };
     readonly E303: {
         readonly title: 'A runtime plugin imports a shared module';
@@ -161,7 +174,7 @@ export declare const ERROR_CATALOGUE: {
     };
     readonly E304: {
         readonly title: 'A bundle is over its budget';
-        readonly fix: 'Cut what the app ships on first load, or raise the budget in mfeflow.json ("budget") or mfe.json ("budgets") on purpose.';
+        readonly fix: 'Cut what the app ships on first load, or raise the budget in mfeflow.json ("budget") or mfeflow.app.json ("budgets") on purpose.';
     };
     readonly E305: {
         readonly title: 'There is no build output to measure';
@@ -171,6 +184,10 @@ export declare const ERROR_CATALOGUE: {
         readonly title: 'A dev server could not start';
         readonly fix: "Free the port or change it in mfeflow.json and the app's rsbuild config, then run `mfeflow dev` again.";
     };
+    readonly E307: {
+        readonly title: 'The shell to check against could not be read';
+        readonly fix: 'Pass --against a registry index, a deployed shell mf-manifest.json or a local file of either. A URL must be https (http only for localhost) and under 1 MB.';
+    };
     readonly E401: {
         readonly title: 'Could not fetch from the registry';
         readonly fix: 'Check the URL in "registries" and your network, then try again.';
@@ -189,7 +206,7 @@ export declare const ERROR_CATALOGUE: {
     };
     readonly E501: {
         readonly title: 'A deploy failed the schema gate';
-        readonly fix: "Fix what the message names: the remote's mfe.json, its mf-manifest.json or the version. Nothing was uploaded. See https://mfeflow.github.io/mfeflow/guide/deploy-and-rollback.";
+        readonly fix: "Fix what the message names: the remote's mfeflow.app.json, its mf-manifest.json or the version. Nothing was uploaded. See https://mfeflow.github.io/mfeflow/guide/deploy-and-rollback.";
     };
     readonly E502: {
         readonly title: 'A route of this remote overlaps a route of another remote';
@@ -201,7 +218,7 @@ export declare const ERROR_CATALOGUE: {
     };
     readonly E504: {
         readonly title: 'The remote is over its first-load JS budget';
-        readonly fix: "Cut what the remote loads first, or raise budgets.initialJsKb in its mfe.json on purpose. Nothing was uploaded. See https://mfeflow.github.io/mfeflow/guide/deploy-and-rollback.";
+        readonly fix: "Cut what the remote loads first, or raise budgets.initialJsKb in its mfeflow.app.json on purpose. Nothing was uploaded. See https://mfeflow.github.io/mfeflow/guide/deploy-and-rollback.";
     };
     readonly E505: {
         readonly title: 'A rollout was asked for, and a static host cannot split traffic';
@@ -243,6 +260,22 @@ export declare const ERROR_CATALOGUE: {
         readonly title: 'The registry changed a feature since you added it';
         readonly fix: 'Nothing was written. Look at what changed; if you accept the new content, run the command again with --accept-changed-content.';
     };
+    readonly E601: {
+        readonly title: 'Cannot tell which version of mfeflow made this project';
+        readonly fix: 'Add "cli": "<version>" to mfeflow.json (the version you created the project with), or give the shell a plain @mfeflow/runtime range in its package.json, then run the command again.';
+    };
+    readonly E602: {
+        readonly title: 'The project is newer than the version you are upgrading to';
+        readonly fix: 'Upgrade only moves forward. Install a newer mfeflow, or leave the project as it is.';
+    };
+    readonly E603: {
+        readonly title: 'A feature migration could not be loaded or failed';
+        readonly fix: 'Nothing was written. Update mfeflow to a build that ships the migration, or report the feature and versions named above.';
+    };
+    readonly E604: {
+        readonly title: 'Files you changed need a decision';
+        readonly fix: 'Nothing was written. Run `mfeflow upgrade --dry-run` to see each diff, then pass --accept <path> to take the new version of a file, --keep <path> to keep yours, or `all` for every file.';
+    };
 };
 export type ErrorCode = keyof typeof ERROR_CATALOGUE;
 export interface MfeflowErrorOptions {

package/dist/features/load.d.ts

@@ -7,6 +7,8 @@ export interface LoadedFeature {
     trust: Trust;
     /** Reads a `from` file of a local feature. Absent for remote features. */
     readAsset?: (relative: string) => Promise<string>;
+    /** Folder of a local feature; migration modules are loaded from here. Absent for remote features. */
+    dir?: string;
     /** `sha256-<hex>` of the feature.json a registry served. Absent for local features. */
     integrity?: string;
 }

package/dist/fs.d.ts

@@ -22,3 +22,8 @@ export declare function readIfExists(ops: FsOps, file: string): Promise<string |
 export declare function tempSibling(file: string): string;
 /** Writes through a temp file and a rename, so readers never see half a file. */
 export declare function writeFileAtomic(ops: FsOps, file: string, content: string): Promise<void>;
+/**
+ * The first part of a project-relative path, from the root down, that is itself a symlink:
+ * a folder on the way or the file. Undefined when none is. The root itself is not looked at.
+ */
+export declare function symlinkedPrefix(ops: FsOps, root: string, relative: string): Promise<string | undefined>;

package/dist/index.d.ts

@@ -4,13 +4,16 @@ export declare function packageInfo(): {
     version: string;
 };
 export { ERROR_CATALOGUE, hasErrno, isMfeflowError, messageOf, MfeflowError, type ErrorCode, type MfeflowErrorOptions, } from './errors.js';
+export { APP_FILE, LEGACY_APP_FILE, legacyAppFileNotice, readAppFile, type AppFileName, type AppFileText, } from './app-file.js';
 export { hashContent } from './hash.js';
 export { inOrder } from './sequence.js';
-export { realFs, writeFileAtomic, type FsOps } from './fs.js';
+export { realFs, symlinkedPrefix, writeFileAtomic, type FsOps } from './fs.js';
 export { findDiverged, findProjectRoot, loadProject, parseProject, PROJECT_FILE, recordPlan, saveProject, serializeProject, type DivergedFile, type MfeflowProject, } from './project.js';
 export { emptyPlan, PlanBuilder, renderDiff, summarize, type ChangeAction, type DependencyAdd, type EnvKeyAdd, type FileChange, type Plan, type PlanBuilderOptions, type PlanFeature, type ReadFile, type ScriptAdd, } from './plan.js';
 export { applyPlan, type ApplyOptions, type ApplyResult, type InstallContext, type InstallStep, } from './apply.js';
+export { detectBaseline, planUpgrade, type DivergedUpgrade, type DivergeReason, type Migration, type UpgradeDecisions, type UpgradeInput, type UpgradePlan, } from './upgrade.js';
 export { renderTemplate, substitute, type TemplateData } from './templates.js';
 export { RUNTIME_CONFIG_FILE, runtimeConfigFiles } from './runtime-config.js';
 export { applyTransform, dotenvKeys, schemaKeys, type SchemaKey } from './transforms/index.js';
+export { detectFederation, planAdoption, type AdoptAppFile, type AdoptInput, type AdoptPlan, type AdoptRemote, type BuildTool, type DetectedApp, type DetectedRemote, type DetectedShared, type DetectFederationOptions, type FederationReport, type FederationRole, type NotAdopted, } from './adopt/index.js';
 export { buildRegistry, fetchFeatureIndex, fetchRemoteText, isProtectedPath, listLocalFeatures, loadFeature, parseFeature, addTrusted, configDirOf, parseTrustEnv, readTrusted, removeTrusted, TRUST_ENV, trustedNamespaces, trustFileIn, type EnvTrust, type Trusted, type TrustedRegistry, getHttps, checkIntegrity, indexedVersion, integrityOf, readCappedText, registryUrl, resolveFeature, resolveOptions, type FetchLike, type FetchResponse, type LoadedFeature, type LoadOptions, type RegistryBuild, type RegistryFile, type ResolveInput, type Trust, } from './features/index.js';