@mfeflow/core 0.3.0 → 0.4.0

package/README.md

@@ -26,8 +26,10 @@ install, commit or the next `mfeflow` command.
   files and the local `features/` folder are refused. Paths are compared after
   Unicode (NFC) and case folding, and names with trailing dots or spaces, `:`,
   invisible characters or Windows device names are refused for every feature.
-- **Scripts** are lower-case words joined by `:`. Lifecycle events, `pnpm:`,
-  `npm:`, `yarn:` and `bun:` prefixes and every `pre` or `post` name are refused.
+- **Scripts** are lower-case words joined by `:` and start with the feature's
+  own name (`segment:check` for `@acme/segment`), so `build`, `lint:*` and
+  other runners never pick them up. Lifecycle events, `pnpm:`, `npm:`, `yarn:`
+  and `bun:` prefixes and every `pre` or `post` name are refused.
 - **Dependencies** take a semver range or a dist-tag. `file:`, `link:`, git,
   URLs, `npm:` aliases, `workspace:` and `catalog:` are refused.
 - **Imports** name a package, a relative path or an `@/` alias, never a URL.

package/dist/errors.d.ts

@@ -125,7 +125,7 @@ export declare const ERROR_CATALOGUE: {
     };
     readonly E210: {
         readonly title: 'Registry namespace is not configured';
-        readonly fix: 'Add it to "registries" in mfeflow.json, for example { "@someone": "https://example.com/{name}.json" }.';
+        readonly fix: 'Add it with `mfeflow registry add @someone https://example.com/{name}.json` (or under "registries" in mfeflow.json).';
     };
     readonly E211: {
         readonly title: 'Files changed since the plan was made';
@@ -179,6 +179,14 @@ export declare const ERROR_CATALOGUE: {
         readonly title: 'The registry returned something that is not a feature';
         readonly fix: 'Ask the registry owner to check the entry. It must be a feature.json document.';
     };
+    readonly E403: {
+        readonly title: "The registry's index.json is not valid";
+        readonly fix: 'Ask the registry owner to rebuild it with `mfeflow registry build`. It lists items with a name, version and description.';
+    };
+    readonly E404: {
+        readonly title: 'A feature in the registry folder cannot be published';
+        readonly fix: 'Fix the features listed above. They are checked with the same rules `mfeflow add @namespace/name` applies, so a feature that passes here installs for users.';
+    };
 };
 export type ErrorCode = keyof typeof ERROR_CATALOGUE;
 export interface MfeflowErrorOptions {

package/dist/features/index.d.ts

@@ -1,5 +1,6 @@
 export { listLocalFeatures, loadFeature, parseFeature, type LoadedFeature, type LoadOptions, } from './load.js';
-export { fetchRemoteText, getHttps, readCappedText, registryUrl, type FetchLike, type FetchResponse, } from './remote.js';
+export { fetchFeatureIndex, fetchRemoteText, getHttps, readCappedText, registryUrl, type FetchLike, type FetchResponse, } from './remote.js';
 export { resolveFeature, resolveOptions, type ResolveInput } from './resolve.js';
 export { type Trust } from './policy.js';
 export { isProtectedPath } from './write-policy.js';
+export { buildRegistry, type RegistryBuild, type RegistryFile } from './registry-build.js';

package/dist/features/policy.d.ts

@@ -16,7 +16,7 @@ export declare function isRegistryRange(range: string): boolean;
  * lifecycle events, `pnpm:`/`npm:`/`yarn:`/`bun:` prefixes and every `pre` or
  * `post` name, since what it wraps may be added to package.json later.
  */
-export declare function assertPlainScript(name: string, label: string): void;
+export declare function assertPlainScript(name: string, feature: string, label?: string): void;
 /** Keys check: runs on the raw JSON, before the schema, so "hooks" is named rather than ignored. */
 export declare function assertAllowedKeys(value: Record<string, unknown>, label: string): void;
 /** Unknown op names are their own error, so authors learn what the built-ins are. */

package/dist/features/registry-build.d.ts

@@ -0,0 +1,25 @@
+import { type FeatureRegistryIndex } from '@mfeflow/contracts';
+import { type FsOps } from '../fs.js';
+export interface RegistryFile {
+    /** Relative to the output folder, with forward slashes. */
+    path: string;
+    content: string;
+}
+export interface RegistryBuild {
+    /** The namespace every feature in the folder uses, like `@test`. */
+    namespace: string;
+    index: FeatureRegistryIndex;
+    features: {
+        name: string;
+        version: string;
+        files: string[];
+    }[];
+    /** `index.json` and, per feature, `<name>.json`, `<name>/<version>.json` and `<name>/latest.json`. */
+    files: RegistryFile[];
+}
+/**
+ * Checks every `<dir>/<folder>/feature.json` the way `mfeflow add @namespace/name` will when a user
+ * installs it, and returns the files to host: one registry folder serves any static host. Every
+ * problem is collected, so an author fixes them in one pass. Writes nothing.
+ */
+export declare function buildRegistry(dir: string, ops?: FsOps): Promise<RegistryBuild>;

package/dist/features/remote.d.ts

@@ -1,3 +1,4 @@
+import { type FeatureRegistryItem } from '@mfeflow/contracts';
 /** The part of `Response` the loader uses, so tests can pass a plain object. */
 export interface FetchResponse {
     ok: boolean;
@@ -14,6 +15,8 @@ export type FetchLike = (url: string, init?: {
     signal?: AbortSignal;
     redirect?: 'follow' | 'manual';
 }) => Promise<FetchResponse>;
+/** Largest feature.json or index.json a registry may serve; `registry build` refuses to write more. */
+export declare const MAX_BYTES = 1000000;
 /**
  * The URL a namespaced feature lives at. `{name}` is the part after the slash and
  * `{version}` the version asked for (`latest` when none), both URL-encoded.
@@ -21,9 +24,13 @@ export type FetchLike = (url: string, init?: {
 export declare function registryUrl(name: string, registries: Record<string, string>, version?: string): string;
 /**
  * GETs `url`, following redirects by hand so one that leaves https is refused before it is
- * requested. `code` is the error every failure here throws.
+ * requested. `code` is the error every failure here throws. With `loopback`, a URL that starts
+ * on plain http at 127.0.0.1, localhost or [::1] may stay on such a host; nothing else may
+ * step down to http, and an https URL never ends up on one.
  */
-export declare function getHttps(url: string, fetchImpl: FetchLike, code: 'E109' | 'E401'): Promise<FetchResponse>;
+export declare function getHttps(url: string, fetchImpl: FetchLike, code: 'E109' | 'E401', options?: {
+    loopback?: boolean;
+}): Promise<FetchResponse>;
 /** Downloads the feature.json text for `@ns/name`. */
 export declare function fetchRemoteText(name: string, registries: Record<string, string>, fetchImpl?: FetchLike, version?: string): Promise<string>;
 /**
@@ -32,3 +39,9 @@ export declare function fetchRemoteText(name: string, registries: Record<string,
  * cancelled instead of downloaded. `tooBig` builds the error to throw.
  */
 export declare function readCappedText(response: FetchResponse, maxBytes: number, tooBig: () => Error): Promise<string>;
+/**
+ * The items `<namespace>`'s `index.json` lists. The index sits in the folder the registry's URL
+ * template starts in (see `registryIndexUrl`). Fails with E401 when it cannot be fetched and E403
+ * when it is not an index, so a caller can show one registry's problem and carry on with the rest.
+ */
+export declare function fetchFeatureIndex(namespace: string, registries: Record<string, string>, fetchImpl?: FetchLike): Promise<FeatureRegistryItem[]>;

package/dist/index.d.ts

@@ -6,11 +6,11 @@ export declare function packageInfo(): {
 export { ERROR_CATALOGUE, hasErrno, isMfeflowError, messageOf, MfeflowError, type ErrorCode, type MfeflowErrorOptions, } from './errors.js';
 export { hashContent } from './hash.js';
 export { inOrder } from './sequence.js';
-export { realFs, type FsOps } from './fs.js';
+export { realFs, 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 { 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 { fetchRemoteText, isProtectedPath, listLocalFeatures, loadFeature, parseFeature, getHttps, readCappedText, registryUrl, resolveFeature, resolveOptions, type FetchLike, type FetchResponse, type LoadedFeature, type LoadOptions, type ResolveInput, type Trust, } from './features/index.js';
+export { buildRegistry, fetchFeatureIndex, fetchRemoteText, isProtectedPath, listLocalFeatures, loadFeature, parseFeature, getHttps, readCappedText, registryUrl, resolveFeature, resolveOptions, type FetchLike, type FetchResponse, type LoadedFeature, type LoadOptions, type RegistryBuild, type RegistryFile, type ResolveInput, type Trust, } from './features/index.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { FEATURE_CONDITION, FEATURE_NAME, SCHEMA_URLS, TRANSFORM_OPS, errorDocsUrl, isMfeflowProject, isSafeRelativePath, validateFeatureManifest, validateMfeflowProject } from "@mfeflow/contracts";
+import { FEATURE_CONDITION, FEATURE_NAME, REGISTRY_NAMESPACE, SCHEMA_URLS, TRANSFORM_OPS, errorDocsUrl, isLoopbackHttp, isMfeflowProject, isRegistryProtocol, isSafeRelativePath, registryIndexUrl, registryTemplateProblem, validateFeatureManifest, validateFeatureRegistryIndex, validateMfeflowProject } from "@mfeflow/contracts";
 import { createHash } from "node:crypto";
 import promises from "node:fs/promises";
 import node_path from "node:path";
@@ -8,7 +8,7 @@ import { isMap, isSeq, parseDocument, stringify } from "yaml";
 import { Eta } from "eta";
 import { isArrayExpression, isArrowFunctionExpression, isBooleanLiteral, isCallExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isImportDeclaration, isImportDefaultSpecifier, isImportNamespaceSpecifier, isImportSpecifier, isJSXElement, isJSXFragment, isJSXIdentifier, isMemberExpression, isNode, isNullLiteral, isNumericLiteral, isObjectExpression, isObjectProperty, isParenthesizedExpression, isReturnStatement, isStringLiteral, isTSAsExpression, isTSNonNullExpression, isTSSatisfiesExpression, isUnaryExpression, isValidIdentifier, isVariableDeclaration } from "@babel/types";
 import { parse, parseExpression } from "@babel/parser";
-import { validRange } from "semver";
+import { valid, validRange } from "semver";
 const ERROR_CATALOGUE = {
     E101: {
         title: 'A shared singleton is missing from the shared list',
@@ -132,7 +132,7 @@ const ERROR_CATALOGUE = {
     },
     E210: {
         title: 'Registry namespace is not configured',
-        fix: 'Add it to "registries" in mfeflow.json, for example { "@someone": "https://example.com/{name}.json" }.'
+        fix: 'Add it with `mfeflow registry add @someone https://example.com/{name}.json` (or under "registries" in mfeflow.json).'
     },
     E211: {
         title: 'Files changed since the plan was made',
@@ -185,6 +185,14 @@ const ERROR_CATALOGUE = {
     E402: {
         title: 'The registry returned something that is not a feature',
         fix: 'Ask the registry owner to check the entry. It must be a feature.json document.'
+    },
+    E403: {
+        title: "The registry's index.json is not valid",
+        fix: "Ask the registry owner to rebuild it with `mfeflow registry build`. It lists items with a name, version and description."
+    },
+    E404: {
+        title: 'A feature in the registry folder cannot be published',
+        fix: 'Fix the features listed above. They are checked with the same rules `mfeflow add @namespace/name` applies, so a feature that passes here installs for users.'
     }
 };
 class MfeflowError extends Error {
@@ -1708,15 +1716,24 @@ function registryUrl(name, registries, version) {
             cause: error
         });
     }
-    if ('https:' !== parsed.protocol) throw new MfeflowError('E401', `${url} is not https`);
+    if (!isRegistryProtocol(parsed)) throw new MfeflowError('E401', `${url} is not https (plain http is for 127.0.0.1, localhost and [::1] only)`);
     return parsed.href;
 }
-async function getHttps(url, fetchImpl, code) {
+async function getHttps(url, fetchImpl, code, options = {}) {
     const fail = (at, why, cause)=>{
         throw new MfeflowError(code, `${at}: ${why}`, void 0 === cause ? {} : {
             cause
         });
     };
+    const startsLoopback = true === options.loopback && isLoopbackHttp(new URL(url));
+    const permitted = (target)=>'https:' === target.protocol || startsLoopback && isLoopbackHttp(target);
+    const addressOk = (address)=>{
+        try {
+            return permitted(new URL(address));
+        } catch  {
+            return false;
+        }
+    };
     let current = url;
     for(let hop = 0; hop <= MAX_REDIRECTS; hop += 1){
         let response;
@@ -1728,7 +1745,7 @@ async function getHttps(url, fetchImpl, code) {
         } catch (error) {
             return fail(current, messageOf(error), error);
         }
-        if (void 0 !== response.url && '' !== response.url && !response.url.startsWith('https://')) fail(url, `ended up at ${response.url}, which is not https`);
+        if (void 0 !== response.url && '' !== response.url && !addressOk(response.url)) fail(url, `ended up at ${response.url}, which is not https`);
         if (response.status < 300 || response.status >= 400) return response;
         const location = response.headers?.get('location');
         await response.body?.cancel().catch(()=>void 0);
@@ -1739,14 +1756,16 @@ async function getHttps(url, fetchImpl, code) {
         } catch (error) {
             return fail(current, 'redirected to a bad address', error);
         }
-        if ('https:' !== next.protocol) fail(url, `redirected to ${next.href}, which is not https`);
+        if (!permitted(next)) fail(url, `redirected to ${next.href}, which is not https`);
         current = next.href;
     }
     return fail(url, 'redirected too many times');
 }
 async function fetchRemoteText(name, registries, fetchImpl = realFetch, version) {
     const url = registryUrl(name, registries, version);
-    const response = await getHttps(url, fetchImpl, 'E401');
+    const response = await getHttps(url, fetchImpl, 'E401', {
+        loopback: true
+    });
     if (!response.ok) {
         const hint = 404 === response.status ? `${name} is not in that registry` : void 0;
         throw new MfeflowError('E401', `${url} answered ${String(response.status)}${hint ? `: ${hint}` : ''}`);
@@ -1773,6 +1792,44 @@ async function readCappedText(response, maxBytes, tooBig) {
     }
     return new TextDecoder().decode(Buffer.concat(chunks));
 }
+async function fetchFeatureIndex(namespace, registries, fetchImpl = realFetch) {
+    const template = registries[namespace];
+    if (void 0 === template) throw new MfeflowError('E210', namespace);
+    const problem = registryTemplateProblem(template);
+    if (void 0 !== problem) throw new MfeflowError('E401', `${namespace}: ${problem}`);
+    const url = registryIndexUrl(template);
+    const response = await getHttps(url, fetchImpl, 'E401', {
+        loopback: true
+    });
+    if (!response.ok) {
+        const hint = 404 === response.status ? ': this registry has no index.json' : '';
+        throw new MfeflowError('E401', `${url} answered ${String(response.status)}${hint}`);
+    }
+    const text = await readCappedText(response, MAX_BYTES, ()=>new MfeflowError('E403', `${url} is larger than 1 MB`));
+    let value;
+    try {
+        value = JSON.parse(text);
+    } catch (error) {
+        const reason = messageOf(error).replaceAll(/\p{Cc}/gu, '?');
+        throw new MfeflowError('E403', `${url} is not JSON (${reason})`, {
+            cause: error
+        });
+    }
+    const issues = validateFeatureRegistryIndex(value);
+    if (issues.length > 0) {
+        const shown = issues.slice(0, 3).map((i)=>`${i.path || '(root)'} ${i.message}`);
+        const more = issues.length > 3 ? `; and ${String(issues.length - 3)} more` : '';
+        throw new MfeflowError('E403', `${url}: ${shown.join('; ')}${more}`);
+    }
+    return itemsOf(value);
+}
+function itemsOf(value) {
+    const holder = {
+        items: []
+    };
+    Object.assign(holder, value);
+    return holder.items;
+}
 const ROOTS = new Set([
     'z',
     'v',
@@ -1852,6 +1909,7 @@ const THIRD_PARTY_KEYS = new Set([
     'name',
     'version',
     "description",
+    'keywords',
     'prompts',
     'requires',
     'conflicts',
@@ -1896,7 +1954,7 @@ function isRegistryRange(range) {
     if (range.split(/\s+|\|\|/).some((part)=>TARBALL_NAME.test(part))) return false;
     return DIST_TAG.test(range) || null !== validRange(range);
 }
-function assertPlainScript(name, label) {
+function assertPlainScript(name, feature, label = feature) {
     const reject = (why)=>{
         throw new MfeflowError('E203', `${label}: script "${name}" ${why}`);
     };
@@ -1905,6 +1963,8 @@ function assertPlainScript(name, label) {
     if (MANAGER_PREFIXES.has(prefix)) reject('uses a package manager hook prefix');
     if (LIFECYCLE_SCRIPTS.has(name)) reject('would run on its own (npm lifecycle)');
     if (/^(pre|post)/.test(name)) reject("starts with pre or post, which wraps another script; namespace it, e.g. feature:name");
+    const own = feature.slice(feature.indexOf('/') + 1);
+    if (prefix !== own) reject(`must start with the feature's own name, like ${own}:check, so no other runner picks it up`);
 }
 function assertAllowedKeys(value, label) {
     for (const key of Object.keys(value))if (!THIRD_PARTY_KEYS.has(key)) throw new MfeflowError('E203', `${label}: "${key}" is not allowed in a third-party feature`);
@@ -1935,7 +1995,7 @@ function assertThirdPartyContent(manifest, label) {
         if (!isRegistryRange(dep.range)) throw new MfeflowError('E203', `${label}: ${dep.name}@${dep.range} is not a registry version range`);
     }
     for (const t of manifest.transforms ?? [])assertThirdPartyTransform(t, label);
-    for (const script of manifest.scripts ?? [])assertPlainScript(script.name, label);
+    for (const script of manifest.scripts ?? [])assertPlainScript(script.name, manifest.name, label);
 }
 function assertThirdPartyTransform(t, label) {
     const deny = (why)=>{
@@ -2213,6 +2273,112 @@ async function editFile(builder, file, edit, op) {
     if (isConfig && !await builder.exists(file)) return void await builder.create(file, edit('{}\n'));
     await builder.patch(file, edit);
 }
+const registry_build_text = (value)=>`${JSON.stringify(value, null, 2)}\n`;
+async function buildRegistry(dir, ops = realFs) {
+    let folders;
+    try {
+        folders = (await ops.listDirs(dir)).toSorted((a, b)=>a.localeCompare(b));
+    } catch (error) {
+        throw new MfeflowError('E404', `${dir} is not a folder (${messageOf(error)})`, {
+            cause: error
+        });
+    }
+    const problems = [];
+    const found = [];
+    let looked = 0;
+    for (const folder of folders){
+        const file = node_path.join(dir, folder, 'feature.json');
+        const source = await readIfExists(ops, file);
+        if (void 0 === source) continue;
+        looked += 1;
+        const label = `${folder}/feature.json`;
+        try {
+            const manifest = parseFeature(source, 'third-party', label);
+            const slash = manifest.name.indexOf('/');
+            const bare = manifest.name.slice(slash + 1);
+            const own = (problem)=>problems.push(`${label}: ${problem}`);
+            const namespace = manifest.name.slice(0, slash);
+            if (!REGISTRY_NAMESPACE.test(namespace)) own(`namespace "${namespace}" must start with a letter or digit, like @acme`);
+            if ('index' === bare) own('"index" is taken by the registry index; pick another name');
+            if (valid(manifest.version) !== manifest.version) own(`version "${manifest.version}" must be a semver version like 1.0.0`);
+            if ((manifest.description ?? '') === '') own("description is required; `mfeflow features` shows it next to the name");
+            found.push({
+                folder,
+                namespace,
+                bare,
+                version: manifest.version,
+                description: manifest.description ?? '',
+                keywords: manifest.keywords,
+                json: registry_build_text(manifest)
+            });
+        } catch (error) {
+            if (!isMfeflowError(error)) throw error;
+            problems.push(`${label}: ${error.message.replace(`${label}: `, '')}`);
+        }
+    }
+    if (0 === looked) throw new MfeflowError('E404', `no <folder>/feature.json found in ${dir}`, {
+        fix: 'Put each feature in its own folder next to the others: my-registry/hello/feature.json.'
+    });
+    const namespaces = new Set(found.map((f)=>f.namespace));
+    if (namespaces.size > 1) problems.push(`one registry serves one namespace, but this folder has ${[
+        ...namespaces
+    ].toSorted((a, b)=>a.localeCompare(b)).join(', ')}`);
+    const names = new Map();
+    for (const f of found){
+        const earlier = names.get(f.bare);
+        if (void 0 !== earlier) problems.push(`${f.folder}/feature.json: ${f.bare} is already defined by ${earlier}`);
+        names.set(f.bare, `${f.folder}/feature.json`);
+    }
+    const files = [];
+    const features = [];
+    const items = [];
+    for (const f of found.toSorted((a, b)=>a.bare.localeCompare(b.bare))){
+        const paths = [
+            `${f.bare}.json`,
+            `${f.bare}/${f.version}.json`,
+            `${f.bare}/latest.json`
+        ];
+        if (Buffer.byteLength(f.json, 'utf8') > MAX_BYTES) problems.push(`${f.folder}/feature.json: is larger than 1 MB, which users' installs refuse`);
+        for (const p of paths)files.push({
+            path: p,
+            content: f.json
+        });
+        features.push({
+            name: `${f.namespace}/${f.bare}`,
+            version: f.version,
+            files: paths
+        });
+        items.push({
+            name: f.bare,
+            version: f.version,
+            description: f.description,
+            ...void 0 === f.keywords || 0 === f.keywords.length ? {} : {
+                keywords: f.keywords
+            }
+        });
+    }
+    const index = {
+        $schema: SCHEMA_URLS.featureRegistryIndex,
+        items
+    };
+    for (const issue of validateFeatureRegistryIndex(index))problems.push(`index.json: ${issue.path} ${issue.message}`);
+    if (problems.length > 0) {
+        const list = problems.map((p)=>`\n  - ${p}`).join('');
+        throw new MfeflowError('E404', `${String(problems.length)} problem(s)${list}`);
+    }
+    files.push({
+        path: 'index.json',
+        content: registry_build_text(index)
+    });
+    return {
+        namespace: [
+            ...namespaces
+        ][0] ?? '',
+        index,
+        features,
+        files
+    };
+}
 function packageInfo() {
     const { name, version } = readPackageJson();
     return {
@@ -2220,4 +2386,4 @@ function packageInfo() {
         version
     };
 }
-export { ERROR_CATALOGUE, MfeflowError, PROJECT_FILE, PlanBuilder, RUNTIME_CONFIG_FILE, applyPlan, applyTransform, dotenvKeys, emptyPlan, fetchRemoteText, findDiverged, findProjectRoot, getHttps, hasErrno, hashContent, inOrder, isMfeflowError, isProtectedPath, listLocalFeatures, loadFeature, loadProject, messageOf, packageInfo, parseFeature, parseProject, readCappedText, realFs, recordPlan, registryUrl, renderDiff, renderTemplate, resolveFeature, resolveOptions, runtimeConfigFiles, saveProject, schemaKeys, serializeProject, substitute, summarize };
+export { ERROR_CATALOGUE, MfeflowError, PROJECT_FILE, PlanBuilder, RUNTIME_CONFIG_FILE, applyPlan, applyTransform, buildRegistry, dotenvKeys, emptyPlan, fetchFeatureIndex, fetchRemoteText, findDiverged, findProjectRoot, getHttps, hasErrno, hashContent, inOrder, isMfeflowError, isProtectedPath, listLocalFeatures, loadFeature, loadProject, messageOf, packageInfo, parseFeature, parseProject, readCappedText, realFs, recordPlan, registryUrl, renderDiff, renderTemplate, resolveFeature, resolveOptions, runtimeConfigFiles, saveProject, schemaKeys, serializeProject, substitute, summarize, writeFileAtomic };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mfeflow/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The engine behind the mfeflow CLI: project model, change plans with diffs, atomic apply with rollback, and feature resolution.",
   "keywords": [
     "micro-frontend",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@babel/parser": "8.0.10",
     "@babel/types": "8.0.10",
-    "@mfeflow/contracts": "0.3.0",
+    "@mfeflow/contracts": "0.4.0",
     "diff": "9.0.0",
     "eta": "4.6.0",
     "semver": "7.8.5",