mfeflow 0.4.0 → 0.5.0

package/README.md

@@ -29,6 +29,10 @@ pnpm dev                                    # shell on :4300, remotes on :4311,
 | `mfeflow validate`                    | `mfeflow.json`, every `mfe.json` and every registry entry against their schemas       |
 | `mfeflow check-compat`                | Each remote's shared ranges against the shells it runs in                             |
 | `mfeflow budget`                      | Built first-load JS of the shell and each remote against the cost-model budget        |
+| `mfeflow deploy <remote> --env <env>` | Upload a remote's build to a static registry host and point the env's index at it     |
+| `mfeflow promote <remote>`            | Copy the version one env serves to another env: `--from staging --to prod`            |
+| `mfeflow rollback <remote>`           | Point an env back at the previous version, or `--to <version>`, without a rebuild     |
+| `mfeflow status`                      | What each env serves, the version before it, and drift from `registry/envs`           |
 | `mfeflow --version`, `mfeflow --help` | Version, and help with examples (`mfeflow <command> --help` for one command)          |
 
 Features that ship with it: `core` and `tsconfig` (always), `lint-oxlint`, `url-factory`, `env-t3` and `testing`
@@ -105,8 +109,8 @@ MFEFLOW_E108 The target folder is not empty: /work/app already has notes.txt
 | 3    | project or config problem: `MFEFLOW_E1xx`                               |
 | 4    | feature problem: `MFEFLOW_E2xx`                                         |
 | 5    | build or runtime problem: `MFEFLOW_E3xx`                                |
-| 6    | registry problem: `MFEFLOW_E4xx`                                        |
-| 7    | upgrade problem: `MFEFLOW_E5xx`                                         |
+| 6    | feature registry problem: `MFEFLOW_E4xx`                                |
+| 7    | deploy problem: `MFEFLOW_E5xx`                                          |
 | 130  | cancelled at a prompt (nothing was written), or Ctrl+C in `mfeflow dev` |
 
 ## Try it from a checkout

package/assets/features/analytics-gtm/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "analytics-gtm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Google Tag Manager with Consent Mode v2 behind @mfeflow/analytics: consent defaults before gtm.js, a consent banner hook, page views on route changes, and a typed tracker per remote. The container id comes from the runtime config.",
   "requires": ["core", "tsconfig"],
   "files": [

package/assets/features/ci-github/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "ci-github",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "GitHub Actions workflow for pull requests: lint, typecheck, test, build, doctor, validate, check-compat, budget, runtime-config check and the Playwright smoke test. Opt-in.",
   "requires": ["core"],
   "files": [

package/assets/features/env-t3/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "env-t3",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Typed env with t3-env: env.ts per app fails the build on a missing variable, runtime-config schema checked before deploy, no validator or env value in the browser bundle.",
   "requires": ["core", "tsconfig"],
   "prompts": [

package/assets/features/lint-oxlint/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-oxlint",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "oxlint with type-aware rules on TypeScript 7 (@mfeflow/oxlint-config), and Prettier.",
   "requires": ["core", "tsconfig"],
   "files": [

package/assets/features/testing/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "testing",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Vitest, Testing Library, jsdom and MSW in every app with @mfeflow/testing, and a Playwright smoke test that opens the shell and checks each remote renders.",
   "requires": ["core", "tsconfig"],
   "files": [

package/assets/features/tsconfig/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "tsconfig",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Strict TypeScript 7 presets from @mfeflow/tsconfig, and a typecheck script.",
   "requires": ["core"],
   "files": [

package/assets/features/url-factory/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "url-factory",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Typed endpoint definitions and URL building (@mfeflow/url-factory), src/api/endpoints.ts in every app.",
   "requires": ["core"],
   "files": [

package/assets/templates/monorepo/feature.json

@@ -1,6 +1,6 @@
 {
   "name": "core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The shell, the remotes, the registry and the workspace around them.",
   "files": [
     {
@@ -96,6 +96,12 @@
       "from": "files/shell/src/bootstrap.tsx.eta",
       "template": true
     },
+    {
+      "to": "src/assert.ts",
+      "target": "shell",
+      "from": "files/shell/src/assert.ts.eta",
+      "template": true
+    },
     {
       "to": "src/App.tsx",
       "target": "shell",

package/assets/templates/monorepo/files/root/README.md.eta

@@ -45,6 +45,21 @@ Each is a root script for the `mfeflow` CLI in your devDependencies (`pnpm mfefl
 against the 10 KB a remote may add; set `budget.baselineKb` in `mfeflow.json` (your pages built as one app) to check
 the shell against baseline + 32 KB too.
 
+## Deploy it
+
+```sh
+pnpm build
+pnpm mfeflow deploy catalog --env staging --host file:./site --base-url https://cdn.example.com
+pnpm mfeflow promote catalog --from staging --to prod --host file:./site
+pnpm mfeflow rollback catalog --env prod --host file:./site
+pnpm mfeflow status --host file:./site
+```
+
+`deploy` uploads a remote's `dist` and points an environment at it, `rollback` points it back without a rebuild, and
+`status` shows what is served. Put `host` and `baseUrl` under `registry` in `mfeflow.json` to drop the flags, or use
+`s3://<bucket>` with the `MFEFLOW_S3_*` and `AWS_*` variables. There are no root scripts for these, because the package manager has a deploy command of its own, so
+run them through `pnpm mfeflow`.
+
 ## Before you deploy
 
 `registry/envs/staging` and `registry/envs/prod` point at `example.com`. Replace the hosts

package/assets/templates/monorepo/files/shell/src/assert.ts.eta

@@ -0,0 +1,37 @@
+/* oxlint-disable eslint/no-underscore-dangle -- __MFEFLOW_SINGLETONS__ is the name the rsbuild preset defines */
+import { checkSingletons, reportRemoteError } from '@mfeflow/runtime';
+
+// The shell's rsbuild preset defines the packages it shares; an older preset does not, so fall back.
+declare const __MFEFLOW_SINGLETONS__: readonly string[] | undefined;
+const SINGLETONS =
+  typeof __MFEFLOW_SINGLETONS__ === 'undefined' ? ['react', 'react-dom'] : __MFEFLOW_SINGLETONS__;
+
+// Remotes register their shared packages as they load, so the check repeats for a while.
+const CHECK_EVERY_MS = 3000;
+const STOP_AFTER_MS = 60_000;
+
+declare global {
+  var mfeflowCheckSingletons: (() => ReturnType<typeof checkSingletons>) | undefined;
+}
+
+const reported = new Set<string>();
+
+function check(): ReturnType<typeof checkSingletons> {
+  const result = checkSingletons(SINGLETONS);
+  // `missing` is not a problem: a shared package nothing has loaded yet is not in the share scope.
+  for (const name of result.duplicated) {
+    const problem = `${name} is loaded in more than one version`;
+    if (reported.has(problem)) continue;
+    reported.add(problem);
+    reportRemoteError('<%= it.app.name %>', 'singletons', new Error(problem));
+  }
+  return result;
+}
+
+// Loaded only in development: it reads every loaded remote's share scope.
+globalThis.mfeflowCheckSingletons = check;
+check();
+const timer = setInterval(check, CHECK_EVERY_MS);
+setTimeout(() => {
+  clearInterval(timer);
+}, STOP_AFTER_MS);

package/assets/templates/monorepo/files/shell/src/bootstrap.tsx.eta

@@ -3,6 +3,7 @@ import {
   applyDevOverrides,
   loadRegistryIndex,
   registerRemotesFromIndex,
+  registrySources,
   reportRemoteError,
 } from '@mfeflow/runtime';
 import { App } from './App';
@@ -12,13 +13,22 @@ const DEV = process.env.NODE_ENV !== 'production';
 export async function main(): Promise<void> {
   try {
     // Dev only: ?mfe-override=cart@http://localhost:4312/mf-manifest.json points a remote at your build.
-    const index = applyDevOverrides(await loadRegistryIndex(), { enabled: DEV });
+    // runtime-config.json can set registryUrls (primary, then fallback) and registryOrigins for a CDN-hosted registry;
+    // it never holds up boot for more than 1.5 s, and is not fetched at all when the index is inlined.
+    const { urls, allowedOrigins: cdnOrigins } = await registrySources();
+    const index = applyDevOverrides(await loadRegistryIndex(urls, { allowedOrigins: cdnOrigins }), {
+      enabled: DEV,
+    });
     // In dev the registry points at the remotes' dev servers; elsewhere remotes share the shell's origin.
     const devOrigins = DEV ? index.remotes.map((remote) => new URL(remote.entry).origin) : [];
-    registerRemotesFromIndex(index, { allowedOrigins: [location.origin, ...devOrigins] });
+    registerRemotesFromIndex(index, {
+      allowedOrigins: [location.origin, ...cdnOrigins, ...devOrigins],
+    });
   } catch (error) {
     reportRemoteError('<%= it.app.name %>', 'registry', error);
   }
   const el = document.getElementById('root');
   if (el) createRoot(el).render(<App />);
+  // Development only, so production builds carry nothing for it.
+  if (DEV) void import('./assert');
 }

package/dist/catalog.d.ts

@@ -19,6 +19,10 @@ export interface FeatureSource {
     fetch?: FetchLike | undefined;
     /** The version to ask a registry for, when its URL template can pin one. */
     version?: string | undefined;
+    /** Namespaces the user trusts, so their registries may be on loopback or private addresses. */
+    trusted?: ReadonlySet<string> | undefined;
+    /** Compare the registry index's version with the feature.json's. */
+    checkIndex?: boolean | undefined;
 }
 /** A first-party feature by name, or `@namespace/name` from a configured registry. */
 export declare function loadAny(name: string, source: FeatureSource): Promise<LoadedFeature>;

package/dist/checks/singletons.d.ts

@@ -1,9 +1,6 @@
+import { comparable } from '@mfeflow/registry/static';
 import { type Check, type Finding } from '../findings.js';
-/**
- * The comparable version behind an installed version or a declared range. Undefined for a spec
- * that names no version (`link:`, `workspace:*`, `catalog:`, `latest`): it is only known after install.
- */
-export declare function comparable(version: string): string | undefined;
+export { comparable };
 /** The warning for specs that cannot be compared before install. */
 export declare function unresolved(check: string, code: 'E301' | 'E302', name: string, specs: readonly string[]): Finding;
 export declare const singletonVersions: Check;

package/dist/commands/add.d.ts

@@ -78,6 +78,10 @@ export declare const ADD_ARGS: {
         readonly description: 'add env-key: root, every shell or every remote, instead of --app';
         readonly valueHint: 'root|shell|remotes';
     };
+    readonly 'accept-changed-content': {
+        readonly type: 'boolean';
+        readonly description: 'Take a registry feature whose content differs from the hash recorded in mfeflow.json';
+    };
 };
 /** First-party features in the order `init` applies them, then the rest as typed: a feature may edit another's files. */
 export declare function inCatalogueOrder(names: readonly string[]): string[];

package/dist/commands/deploy.d.ts

@@ -0,0 +1,227 @@
+import type { DeployResult } from '../output.js';
+import type { Runtime } from '../runtime.js';
+export declare const DEPLOY_ARGS: {
+    readonly yes: {
+        readonly type: 'boolean';
+        readonly alias: 'y';
+        readonly description: 'Take the defaults and never prompt';
+    };
+    readonly preset: {
+        readonly type: 'string';
+        readonly description: 'Replay options from a JSON file or an https URL';
+        readonly valueHint: 'file|url';
+    };
+    readonly json: {
+        readonly type: 'boolean';
+        readonly description: 'Print one JSON document on stdout, nothing else';
+    };
+    readonly 'dry-run': {
+        readonly type: 'boolean';
+        readonly description: 'Print the summary and diff, write nothing';
+    };
+    readonly cwd: {
+        readonly type: 'string';
+        readonly description: 'Run as if started in this folder';
+        readonly valueHint: 'dir';
+    };
+    readonly install: {
+        readonly type: 'boolean';
+        readonly default: true;
+        readonly description: 'Run the package manager after writing (--no-install to skip)';
+    };
+    readonly verbose: {
+        readonly type: 'boolean';
+        readonly description: 'Show package manager output and stack traces';
+    };
+    readonly local: {
+        readonly type: 'string';
+        readonly description: 'Link @mfeflow/* from a built mfeflow checkout (env MFEFLOW_LOCAL)';
+        readonly valueHint: 'path';
+    };
+    readonly help: {
+        readonly type: 'boolean';
+        readonly alias: 'h';
+        readonly description: 'Show this help';
+    };
+    readonly host: {
+        readonly type: 'string';
+        readonly description: 'Where the registry lives: file:<dir> or s3://<bucket>[/prefix] (default registry.host)';
+        readonly valueHint: 'spec';
+    };
+    readonly 'base-url': {
+        readonly type: 'string';
+        readonly description: "Where the host's files are served from (default registry.baseUrl)";
+        readonly valueHint: 'url';
+    };
+    readonly 'shell-manifest': {
+        readonly type: 'string';
+        readonly description: "The shell's deployed mf-manifest.json (default envs/<env>/shell/ on the host)";
+        readonly valueHint: 'file';
+    };
+    readonly env: {
+        readonly type: 'string';
+        readonly description: 'Environment to deploy to';
+        readonly valueHint: 'env';
+    };
+    readonly version: {
+        readonly type: 'string';
+        readonly description: "Version to publish (default: the remote's package.json version)";
+        readonly valueHint: 'v';
+    };
+    readonly dist: {
+        readonly type: 'string';
+        readonly description: 'Build output folder inside the remote (default dist)';
+        readonly valueHint: 'dir';
+    };
+    readonly publish: {
+        readonly type: 'boolean';
+        readonly default: true;
+        readonly description: 'Move the index to the new version (--no-publish uploads the files and stops)';
+    };
+};
+export declare const PROMOTE_ARGS: {
+    readonly yes: {
+        readonly type: 'boolean';
+        readonly alias: 'y';
+        readonly description: 'Take the defaults and never prompt';
+    };
+    readonly preset: {
+        readonly type: 'string';
+        readonly description: 'Replay options from a JSON file or an https URL';
+        readonly valueHint: 'file|url';
+    };
+    readonly json: {
+        readonly type: 'boolean';
+        readonly description: 'Print one JSON document on stdout, nothing else';
+    };
+    readonly 'dry-run': {
+        readonly type: 'boolean';
+        readonly description: 'Print the summary and diff, write nothing';
+    };
+    readonly cwd: {
+        readonly type: 'string';
+        readonly description: 'Run as if started in this folder';
+        readonly valueHint: 'dir';
+    };
+    readonly install: {
+        readonly type: 'boolean';
+        readonly default: true;
+        readonly description: 'Run the package manager after writing (--no-install to skip)';
+    };
+    readonly verbose: {
+        readonly type: 'boolean';
+        readonly description: 'Show package manager output and stack traces';
+    };
+    readonly local: {
+        readonly type: 'string';
+        readonly description: 'Link @mfeflow/* from a built mfeflow checkout (env MFEFLOW_LOCAL)';
+        readonly valueHint: 'path';
+    };
+    readonly help: {
+        readonly type: 'boolean';
+        readonly alias: 'h';
+        readonly description: 'Show this help';
+    };
+    readonly host: {
+        readonly type: 'string';
+        readonly description: 'Where the registry lives: file:<dir> or s3://<bucket>[/prefix] (default registry.host)';
+        readonly valueHint: 'spec';
+    };
+    readonly 'base-url': {
+        readonly type: 'string';
+        readonly description: "Where the host's files are served from (default registry.baseUrl)";
+        readonly valueHint: 'url';
+    };
+    readonly 'shell-manifest': {
+        readonly type: 'string';
+        readonly description: "The shell's deployed mf-manifest.json (default envs/<env>/shell/ on the host)";
+        readonly valueHint: 'file';
+    };
+    readonly from: {
+        readonly type: 'string';
+        readonly description: 'Environment to copy the version from';
+        readonly valueHint: 'env';
+    };
+    readonly to: {
+        readonly type: 'string';
+        readonly description: 'Environment to point at it';
+        readonly valueHint: 'env';
+    };
+};
+export declare const ROLLBACK_ARGS: {
+    readonly yes: {
+        readonly type: 'boolean';
+        readonly alias: 'y';
+        readonly description: 'Take the defaults and never prompt';
+    };
+    readonly preset: {
+        readonly type: 'string';
+        readonly description: 'Replay options from a JSON file or an https URL';
+        readonly valueHint: 'file|url';
+    };
+    readonly json: {
+        readonly type: 'boolean';
+        readonly description: 'Print one JSON document on stdout, nothing else';
+    };
+    readonly 'dry-run': {
+        readonly type: 'boolean';
+        readonly description: 'Print the summary and diff, write nothing';
+    };
+    readonly cwd: {
+        readonly type: 'string';
+        readonly description: 'Run as if started in this folder';
+        readonly valueHint: 'dir';
+    };
+    readonly install: {
+        readonly type: 'boolean';
+        readonly default: true;
+        readonly description: 'Run the package manager after writing (--no-install to skip)';
+    };
+    readonly verbose: {
+        readonly type: 'boolean';
+        readonly description: 'Show package manager output and stack traces';
+    };
+    readonly local: {
+        readonly type: 'string';
+        readonly description: 'Link @mfeflow/* from a built mfeflow checkout (env MFEFLOW_LOCAL)';
+        readonly valueHint: 'path';
+    };
+    readonly help: {
+        readonly type: 'boolean';
+        readonly alias: 'h';
+        readonly description: 'Show this help';
+    };
+    readonly host: {
+        readonly type: 'string';
+        readonly description: 'Where the registry lives: file:<dir> or s3://<bucket>[/prefix] (default registry.host)';
+        readonly valueHint: 'spec';
+    };
+    readonly 'base-url': {
+        readonly type: 'string';
+        readonly description: "Where the host's files are served from (default registry.baseUrl)";
+        readonly valueHint: 'url';
+    };
+    readonly 'shell-manifest': {
+        readonly type: 'string';
+        readonly description: "The shell's deployed mf-manifest.json (default envs/<env>/shell/ on the host)";
+        readonly valueHint: 'file';
+    };
+    readonly env: {
+        readonly type: 'string';
+        readonly description: 'Environment to roll back';
+        readonly valueHint: 'env';
+    };
+    readonly to: {
+        readonly type: 'string';
+        readonly description: 'Version to go back to (default: the previous one)';
+        readonly valueHint: 'v';
+    };
+    readonly force: {
+        readonly type: 'boolean';
+        readonly description: 'Roll back even if the schema, route or compatibility checks fail (the files must still exist)';
+    };
+};
+export declare function formatDeploy(result: DeployResult): string;
+export declare function runDeploy(rt: Runtime, args: Record<string, unknown>, raw: readonly string[]): Promise<DeployResult>;
+export declare function runPromote(rt: Runtime, args: Record<string, unknown>, raw: readonly string[]): Promise<DeployResult>;
+export declare function runRollback(rt: Runtime, args: Record<string, unknown>, raw: readonly string[]): Promise<DeployResult>;

package/dist/commands/status.d.ts

@@ -0,0 +1,58 @@
+import type { StatusResult } from '../output.js';
+import type { Runtime } from '../runtime.js';
+export declare const STATUS_ARGS: {
+    readonly yes: {
+        readonly type: 'boolean';
+        readonly alias: 'y';
+        readonly description: 'Take the defaults and never prompt';
+    };
+    readonly preset: {
+        readonly type: 'string';
+        readonly description: 'Replay options from a JSON file or an https URL';
+        readonly valueHint: 'file|url';
+    };
+    readonly json: {
+        readonly type: 'boolean';
+        readonly description: 'Print one JSON document on stdout, nothing else';
+    };
+    readonly 'dry-run': {
+        readonly type: 'boolean';
+        readonly description: 'Print the summary and diff, write nothing';
+    };
+    readonly cwd: {
+        readonly type: 'string';
+        readonly description: 'Run as if started in this folder';
+        readonly valueHint: 'dir';
+    };
+    readonly install: {
+        readonly type: 'boolean';
+        readonly default: true;
+        readonly description: 'Run the package manager after writing (--no-install to skip)';
+    };
+    readonly verbose: {
+        readonly type: 'boolean';
+        readonly description: 'Show package manager output and stack traces';
+    };
+    readonly local: {
+        readonly type: 'string';
+        readonly description: 'Link @mfeflow/* from a built mfeflow checkout (env MFEFLOW_LOCAL)';
+        readonly valueHint: 'path';
+    };
+    readonly help: {
+        readonly type: 'boolean';
+        readonly alias: 'h';
+        readonly description: 'Show this help';
+    };
+    readonly env: {
+        readonly type: 'string';
+        readonly description: 'Only this environment (default: every env on the host, and every folder in registry/envs but dev)';
+        readonly valueHint: 'env';
+    };
+    readonly host: {
+        readonly type: 'string';
+        readonly description: 'Where the registry lives: file:<dir> or s3://<bucket>[/prefix] (default registry.host)';
+        readonly valueHint: 'spec';
+    };
+};
+export declare function formatStatus(result: StatusResult): string;
+export declare function runStatus(rt: Runtime, args: Record<string, unknown>, raw: readonly string[]): Promise<StatusResult>;

package/dist/deploy-testing.d.ts

@@ -0,0 +1,41 @@
+import type { RegistryIndexRemote } from '@mfeflow/contracts';
+import { type DeployResult, type FailureResult, type StatusResult } from './output.js';
+import { type TestRuntime } from './testing.js';
+export declare const BASE_URL = "https://cdn.test";
+interface Ran<T> {
+    code: number;
+    result: T;
+    rt: TestRuntime;
+}
+export interface Fixture {
+    root: string;
+    site: string;
+    cleanup(): Promise<void>;
+    /** `mfeflow <argv> --json` against this project and host, for the commands that print a deploy result. */
+    run(...argv: string[]): Promise<Ran<DeployResult>>;
+    /** The same, for a run that must fail with an error document. */
+    fail(...argv: string[]): Promise<Ran<FailureResult>>;
+    /** `mfeflow status <argv> --json`. */
+    status(...argv: string[]): Promise<Ran<StatusResult>>;
+    /** What the host serves for `env`, read straight from disk. */
+    served(env: string, remote?: string): Promise<RegistryIndexRemote | undefined>;
+    hostTree(): Promise<Record<string, string>>;
+    localTree(): Promise<Record<string, string>>;
+}
+/** An object read from JSON text, for tests that poke at it. */
+export declare function parseObject(text: string): Record<string, unknown>;
+export declare function readObject(file: string): Promise<Record<string, unknown>>;
+export declare function failureOf(text: string): FailureResult;
+export declare function statusOf(text: string): StatusResult;
+export declare function deployOf(text: string): DeployResult;
+/** Writes a remote's build: a manifest, an entry and one expose, with content that differs by `marker`. */
+export declare function buildRemote(root: string, name: string, version: string, options?: {
+    marker?: string;
+    entryBytes?: number;
+    reactRange?: string;
+}): Promise<void>;
+export declare function fixture(options?: {
+    env?: Record<string, string>;
+    configure?: boolean;
+}): Promise<Fixture>;
+export {};

package/dist/devregistry.d.ts

@@ -1,10 +1,9 @@
+import type { RegistryIndex, RegistryIndexRemote } from '@mfeflow/contracts';
 import type { ProjectView } from './inspect.js';
-export interface DevRemote {
-    name: string;
-    entry: string;
+export type DevRemote = RegistryIndexRemote & {
     version: string;
-}
-export interface DevIndex {
+};
+export interface DevIndex extends RegistryIndex {
     remotes: DevRemote[];
 }
 /** `name=url` flags as a map. A bare origin means its `/mf-manifest.json`. */

package/dist/exit.d.ts

@@ -8,7 +8,7 @@ export declare const EXIT: {
     readonly feature: 4;
     readonly build: 5;
     readonly registry: 6;
-    readonly upgrade: 7;
+    readonly deploy: 7;
     readonly cancelled: 130;
 };
 /** Raised when the user backs out of a prompt. */

package/dist/hosts.d.ts

@@ -0,0 +1,25 @@
+import { type RegistryHost } from '@mfeflow/registry/static';
+export type HostSpec = {
+    kind: 'file';
+    dir: string;
+} | {
+    kind: 's3';
+    bucket: string;
+    prefix: string;
+};
+/** `file:<dir>` or `s3://<bucket>[/prefix]`. A folder is resolved against `cwd`. */
+export declare function parseHostSpec(spec: string, cwd: string): HostSpec;
+/** The host as shown to people and in `--json`: never an endpoint or a credential. */
+export declare function describeHost(host: HostSpec): string;
+type Env = Readonly<Record<string, string | undefined>>;
+/** The secret values the environment holds, so no message can echo them. */
+export declare function secretsOf(env: Env): string[];
+export declare function redact(text: string, secrets: readonly string[]): string;
+export interface OpenOptions {
+    env: Env;
+    /** For tests: stands in for the network. */
+    fetch?: typeof fetch;
+}
+/** Opens the host. S3 settings and credentials come from the environment only. */
+export declare function openHost(spec: HostSpec, options: OpenOptions): Promise<RegistryHost>;
+export {};

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { main } from './cli.js';
 export { COMMANDS } from './cli.js';
 export { EXIT, exitCodeFor } from './exit.js';
 export { validateResult } from './output.js';
-export type { AddResult, BudgetResult, DevResult, CliResult, FailureResult, FeatureInfo, FeaturesResult, InitResult, PlanReport, RegistryEntryInfo, RegistryResult, RegistryStatus, ReportResult, } from './output.js';
+export type { AddResult, BudgetResult, DevResult, DeployResult, CliResult, FailureResult, FeatureInfo, FeaturesResult, InitResult, PlanReport, RegistryEntryInfo, RegistryResult, RegistryStatus, ReportResult, StatusResult, } from './output.js';
 export { realRuntime, type Runtime } from './runtime.js';
 export type { Io } from './io.js';
 export type { Prompter } from './prompter.js';