@empire-builder-kit/nx 1.0.0-rc.4 → 1.0.0-rc.41

package/src/foundation/stages.d.ts

@@ -10,6 +10,7 @@ export declare function isFoundationStage(stage: string): stage is FoundationSta
 export declare function isPersonalStage(stage: string): boolean;
 export declare function requireFoundationStage(stage: string): FoundationStage;
 export declare function resolveFoundationStages(options: {
+    activeFoundationStages?: readonly string[];
     consumerStage: string;
     foundationStage?: string;
 }): FoundationStageResolution;

package/src/foundation/stages.js

@@ -34,6 +34,13 @@ function requireFoundationStage(stage) {
     return normalized;
 }
 function resolveFoundationStages(options) {
+    if (options.activeFoundationStages !== undefined &&
+        (options.activeFoundationStages.length === 0 ||
+            new Set(options.activeFoundationStages).size !==
+                options.activeFoundationStages.length ||
+            options.activeFoundationStages.some((stage) => !isFoundationStage(stage)))) {
+        throw new Error('Active Foundation stages must be a nonempty unique subset of development, staging, and production.');
+    }
     const consumerStage = requireStage(options.consumerStage, 'Consumer stage');
     if (!isFoundationStage(consumerStage) && !isPersonalStage(consumerStage)) {
         throw new Error(`Consumer stage ${consumerStage} is neither canonical nor a framework-derived personal stage.`);
@@ -50,6 +57,10 @@ function resolveFoundationStages(options) {
         }
         throw new Error(`Personal consumer stage ${consumerStage} may use only the development Foundation.`);
     }
+    if (options.activeFoundationStages !== undefined &&
+        !options.activeFoundationStages.includes(foundationStage)) {
+        throw new Error(`Foundation stage ${foundationStage} is inactive for this deployment profile.`);
+    }
     return {
         consumerStage,
         foundationStage,

package/src/generators/blueprint/blueprint.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from '@nx/devkit';
+import type { BlueprintGeneratorSchema } from './schema.js';
+/** Scaffold source owned by the adopter, without executing it or minting trust. */
+export declare function blueprintGenerator(tree: Tree, options: BlueprintGeneratorSchema): Promise<void>;
+export default blueprintGenerator;

package/src/generators/blueprint/blueprint.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blueprintGenerator = blueprintGenerator;
+const devkit_1 = require("@nx/devkit");
+const prettier_1 = require("prettier");
+const semver_1 = require("semver");
+const validation_js_1 = require("../../validation.js");
+const manifest_js_1 = require("../../blueprints/manifest.js");
+const post_generation_install_js_1 = require("../post-generation-install.js");
+const files_js_1 = require("./files.js");
+/** Scaffold source owned by the adopter, without executing it or minting trust. */
+async function blueprintGenerator(tree, options) {
+    const name = options.name;
+    if (typeof name !== 'string' ||
+        name.length > 63 ||
+        !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(name) ||
+        /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/.test(name)) {
+        throw new Error('Blueprint name must be a lowercase hyphenated name of at most 63 characters.');
+    }
+    (0, post_generation_install_js_1.assertPostGenerationInstallWorkspaceAvailable)(tree, `generator:blueprint:${name}`);
+    const workspace = (0, devkit_1.readJson)(tree, 'package.json');
+    if (!(0, validation_js_1.isRecord)(workspace) ||
+        typeof workspace.name !== 'string' ||
+        !/^[a-z0-9][a-z0-9-]*$/.test(workspace.name) ||
+        !(0, validation_js_1.isRecord)(workspace.devDependencies) ||
+        typeof workspace.devDependencies['@empire-builder-kit/nx'] !== 'string' ||
+        !(0, semver_1.valid)(workspace.devDependencies['@empire-builder-kit/nx'])) {
+        throw new Error('Blueprint authoring requires an EBK workspace with an unscoped name and exact @empire-builder-kit/nx version.');
+    }
+    if (workspace.ebk !== undefined && !(0, validation_js_1.isRecord)(workspace.ebk)) {
+        throw new Error('Workspace ebk configuration must be an object.');
+    }
+    const ebk = (0, validation_js_1.isRecord)(workspace.ebk) ? workspace.ebk : {};
+    if (ebk.blueprints !== undefined && !(0, validation_js_1.isRecord)(ebk.blueprints)) {
+        throw new Error('Workspace ebk.blueprints configuration must be an object.');
+    }
+    const blueprints = (0, validation_js_1.isRecord)(ebk.blueprints) ? ebk.blueprints : {};
+    if ((blueprints.localPackages !== undefined &&
+        (!(0, validation_js_1.isRecord)(blueprints.localPackages) ||
+            Object.values(blueprints.localPackages).some((path) => typeof path !== 'string'))) ||
+        (blueprints.localAuthoringPackages !== undefined &&
+            (!Array.isArray(blueprints.localAuthoringPackages) ||
+                blueprints.localAuthoringPackages.some((entry) => typeof entry !== 'string')))) {
+        throw new Error('Existing Blueprint local authoring mappings must be valid before scaffolding.');
+    }
+    const root = `blueprints/${name}`;
+    const project = `blueprint-${name}`;
+    const packageName = `@${workspace.name}/blueprint-${name}`;
+    const localPackages = (blueprints.localPackages ?? {});
+    const localAuthoringPackages = (blueprints.localAuthoringPackages ??
+        []);
+    if (tree.isFile('blueprints') ||
+        tree.exists(root) ||
+        tree.children(root).length > 0 ||
+        tree.children('blueprints').some((entry) => entry.toLowerCase() === name) ||
+        (0, devkit_1.getProjects)(tree).has(project) ||
+        Object.prototype.hasOwnProperty.call(localPackages, packageName) ||
+        Object.values(localPackages).includes(root)) {
+        throw new Error(`Blueprint ${name} already has files, a project, or a local mapping. Choose a new name; existing authoring source is never overwritten.`);
+    }
+    const files = (0, files_js_1.createBlueprintAuthoringFiles)({
+        engine: workspace.devDependencies['@empire-builder-kit/nx'],
+        name,
+        packageName,
+        root,
+    });
+    const manifest = (0, manifest_js_1.validateBlueprintManifest)(JSON.parse(files['ebk-blueprint.json']));
+    if (!manifest.valid)
+        throw new Error('Generated Blueprint authoring manifest is invalid.');
+    const nextWorkspace = {
+        ...workspace,
+        ebk: {
+            ...ebk,
+            blueprints: {
+                ...blueprints,
+                localPackages: { ...localPackages, [packageName]: root },
+                localAuthoringPackages: [
+                    ...new Set([...localAuthoringPackages, packageName]),
+                ],
+            },
+        },
+    };
+    const planned = {
+        ...Object.fromEntries(Object.entries(files).map(([path, contents]) => [
+            `${root}/${path}`,
+            contents,
+        ])),
+        'package.json': JSON.stringify(nextWorkspace, null, 2) + '\n',
+    };
+    // Complete validation and formatting before the first write. Only this new
+    // package and the supported user-owned root ebk mapping are in scope.
+    const formatted = await Promise.all(Object.entries(planned).map(async ([path, contents]) => [
+        path,
+        options.skipFormat
+            ? contents
+            : await (0, prettier_1.format)(contents, { filepath: path, singleQuote: true }),
+    ]));
+    for (const [path, contents] of formatted)
+        tree.write(path, contents);
+}
+exports.default = blueprintGenerator;
+//# sourceMappingURL=blueprint.js.map

package/src/generators/blueprint/files.d.ts

@@ -0,0 +1,6 @@
+export declare function createBlueprintAuthoringFiles(options: {
+    engine: string;
+    name: string;
+    packageName: string;
+    root: string;
+}): Record<string, string>;

package/src/generators/blueprint/files.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlueprintAuthoringFiles = createBlueprintAuthoringFiles;
+const json = (value) => JSON.stringify(value, null, 2) + '\n';
+function createBlueprintAuthoringFiles(options) {
+    const { engine, name, packageName, root } = options;
+    return {
+        'package.json': json({
+            name: packageName,
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+            description: `Adopter-owned ${name} Blueprint`,
+            files: [
+                'ebk-blueprint.json',
+                'schema.json',
+                'generator.mjs',
+                'templates',
+            ],
+            scripts: { verify: 'node scripts/verify-recipe.mjs' },
+        }),
+        'ebk-blueprint.json': json({
+            $schema: 'https://empirebuilderkit.dev/schemas/blueprint-v1.json',
+            type: 'empire-builder-kit-blueprint',
+            name: packageName,
+            version: '0.1.0',
+            engine,
+            kind: 'slice',
+            generator: './generator.mjs',
+            inputs: './schema.json',
+            foundation: { contract: '^2.0.0', capabilities: ['deployment'] },
+            verification: ['verify'],
+        }),
+        'schema.json': json({
+            $schema: 'https://json-schema.org/draft/2020-12/schema',
+            title: `${name} Blueprint inputs`,
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                greeting: { type: 'string', minLength: 1, maxLength: 120 },
+            },
+            required: ['greeting'],
+        }),
+        'project.json': json({
+            name: `blueprint-${name}`,
+            root,
+            sourceRoot: root,
+            projectType: 'library',
+            tags: ['scope:tooling', 'type:blueprint', 'private'],
+            targets: {
+                verify: {
+                    cache: false,
+                    executor: 'nx:run-commands',
+                    options: {
+                        command: 'node scripts/verify-recipe.mjs',
+                        cwd: root,
+                        forwardAllArgs: false,
+                    },
+                },
+            },
+        }),
+        'generator.mjs': `import { readFileSync } from 'node:fs';
+
+const json = (value) => JSON.stringify(value, null, 2) + '\\n';
+const greetingTemplate = readFileSync(new URL('./templates/greeting.mjs', import.meta.url), 'utf8');
+const verifyTemplate = readFileSync(new URL('./templates/verify.mjs', import.meta.url), 'utf8');
+
+export default function generate(context) {
+  // EBK validates schema/capabilities first; keep the recipe independently testable.
+  if (typeof context.inputs.greeting !== 'string' || context.inputs.greeting.length < 1 || context.inputs.greeting.length > 120) {
+    throw new Error('greeting must contain 1–120 characters.');
+  }
+  return {
+    contracts: { consumes: [], publishes: [] },
+    projects: [context.name],
+    files: [
+      {
+        path: 'package.json', mode: 'managed',
+        managedJsonPointers: ['/name', '/version', '/private', '/type'],
+        contents: json({ name: context.workspace.scope + '/' + context.name, version: '0.0.0', private: true, type: 'module' }),
+      },
+      {
+        path: 'project.json', mode: 'managed',
+        contents: json({
+          name: context.name, root: context.root, sourceRoot: context.root + '/features',
+          projectType: 'application', implicitDependencies: ['foundation'],
+          tags: ['scope:product-slice', 'type:slice', 'type:external-blueprint'],
+          targets: {
+            verify: {
+              executor: '@empire-builder-kit/nx:blueprint-verification',
+              cache: false, inputs: [], syncGenerators: [], dependsOn: [],
+              options: { kind: 'node', script: 'scripts/verify.mjs' },
+            },
+          },
+        }),
+      },
+      {
+        path: 'features/greeting.mjs', mode: 'seeded',
+        contents: greetingTemplate.replace('__GREETING_JSON__', () => JSON.stringify(context.inputs.greeting)),
+      },
+      { path: 'scripts/verify.mjs', mode: 'managed', contents: verifyTemplate },
+    ],
+  };
+}
+`,
+        'templates/greeting.mjs': `const greeting = __GREETING_JSON__;
+
+export function greet(name) {
+  if (typeof name !== 'string' || name.trim().length < 1 || name.length > 100) {
+    throw new Error('name must contain 1–100 characters.');
+  }
+  return { message: greeting + ', ' + name.trim(), recipient: name.trim() };
+}
+`,
+        'templates/verify.mjs': `import assert from 'node:assert/strict';
+import { greet } from '../features/greeting.mjs';
+
+assert.equal(greet('reader').recipient, 'reader');
+assert.equal(greet(' reader ').recipient, 'reader');
+assert.equal(typeof greet('reader').message, 'string');
+for (const invalid of [null, undefined, '', ' ', 42, 'a'.repeat(101)]) {
+  assert.throws(() => greet(invalid));
+}
+process.stdout.write('Blueprint feature verification passed.\\n');
+`,
+        'scripts/verify-recipe.mjs': `import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import generate from '../generator.mjs';
+
+const manifest = JSON.parse(readFileSync(new URL('../ebk-blueprint.json', import.meta.url), 'utf8'));
+const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+assert.equal(packageJson.name, manifest.name);
+assert.equal(packageJson.version, manifest.version);
+for (const name of ['billing', 'notifications']) {
+  const context = {
+    foundation: { contractVersion: '2.0.0', capabilities: ['deployment'] },
+    inputs: { greeting: 'Hello \\"reader\\" \\n' }, manifest, name, root: 'packages/' + name,
+    workspace: { name: 'recipe-proof', scope: '@recipe-proof', framework: { nx: manifest.engine, runtime: manifest.engine } },
+  };
+  const plan = generate(context);
+  assert.deepEqual(generate(context), plan);
+  assert.deepEqual(plan.projects, [name]);
+  assert.equal(new Set(plan.files.map((file) => file.path)).size, plan.files.length);
+  for (const file of plan.files) {
+    assert.ok(!file.path.startsWith('/') && !file.path.split('/').includes('..'));
+    assert.ok(['managed', 'seeded'].includes(file.mode));
+  }
+  const feature = plan.files.find((file) => file.path === 'features/greeting.mjs');
+  assert.equal(feature.mode, 'seeded');
+  const { greet } = await import('data:text/javascript;base64,' + Buffer.from(feature.contents).toString('base64'));
+  assert.equal(greet('author').message, context.inputs.greeting + ', author');
+  assert.throws(() => greet(''));
+  assert.throws(() => generate({ ...context, inputs: { greeting: '' } }));
+  const project = JSON.parse(plan.files.find((file) => file.path === 'project.json').contents);
+  assert.equal(project.root, context.root);
+  assert.equal(project.targets.verify.executor, '@empire-builder-kit/nx:blueprint-verification');
+  assert.equal(project.targets.verify.cache, false);
+}
+process.stdout.write('Blueprint recipe verification passed.\\n');
+`,
+        'README.md': `# ${name} Blueprint
+
+This entire authoring package is yours. Edit its manifest, schema, generator,
+templates and verification together. EBK does not mark these authoring files
+managed or overwrite them during a workspace upgrade.
+
+The manifest's \`engine\` intentionally pins the framework version used to
+scaffold this recipe. A workspace upgrade does not assert compatibility or
+rewrite this adopter-owned pin. Before using a newer EBK version, test this
+recipe in a disposable upgraded workspace, update \`ebk-blueprint.json\`'s
+\`engine\` to that tested exact version, and run the recipe verification below.
+Then dry-run/generate and verify an instance and exercise a report-first instance
+upgrade with seeded edits preserved. Bump the recipe's package and manifest
+versions together and renew the integrity-bound trust record for changed bytes.
+Do not widen the engine range merely to suppress a compatibility refusal.
+
+Run \`pnpm nx run blueprint-${name}:verify\` to execute the recipe against two
+Slice identities, check deterministic output, and run its seeded feature.
+Then dry-run an instance from the workspace root:
+
+\`\`\`bash
+pnpm nx g @empire-builder-kit/nx:slice example --blueprint=${packageName}@0.1.0 --inputs='{"greeting":"Hello"}' --dry-run
+\`\`\`
+
+The generator added this exact local authoring mapping in root \`package.json\`.
+It did not change protected trust, install a dependency, run publisher code,
+create a receipt, or call AWS. The existing reviewed trust policy/snapshot and
+local Docker publisher sandbox are still required for actual Slice generation.
+If refused, follow the exact trust diagnostic; never delete the policy or
+invent protected refs to get past it.
+
+This starter recipe creates a tested domain function, not infrastructure. Add
+your declared infrastructure and lifecycle targets to its file plan before
+claiming deploy/refresh/remove support. Depend only on the public EBK packages
+and Foundation capability contracts; do not import Foundation internals or
+change another Slice. Prefer DynamoDB for application persistence. Declare SQL
+only for a concrete relational requirement, not for framework inbox/outbox work.
+
+The recipe returns \`managed\` mechanics and \`seeded\` product code. An instance
+customizes \`features/greeting.mjs\`; change its generator/templates here to
+evolve future instances. Keep tests meaningful for allowed customizations.
+Use report-first \`pnpm nx g @empire-builder-kit/nx:upgrade example
+--blueprint=${packageName}@<next-version>\`, review the report, then use \`--apply\`.
+Bump both package and manifest versions together. Same-line upgrades preserve
+seeded feature code. Breaking versions require the existing explicit succession
+contract; no automatic data migration is implied.
+
+Publication is separate: this scaffold is private. Before distributing a
+reviewed exact package, deliberately choose its license, exports and contents,
+remove \`private\`, and establish the normal integrity-bound trust record.
+Local mapping grants neither registry nor protected deployment authority.
+Read the framework Blueprint contract and generated developer-agent runbook for
+protected verification review/receipt retention; do not forge those records.
+`,
+    };
+}
+//# sourceMappingURL=files.js.map

package/src/generators/blueprint/schema.d.ts

@@ -0,0 +1,4 @@
+export interface BlueprintGeneratorSchema {
+  name: string;
+  skipFormat?: boolean;
+}

package/src/generators/blueprint/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "EmpireBuilderKitBlueprint",
+  "title": "Scaffold an adopter-owned EBK Blueprint package",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Lowercase Blueprint recipe name, written under blueprints/<name>",
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+      "maxLength": 63,
+      "$default": { "$source": "argv", "index": 0 }
+    },
+    "skipFormat": { "type": "boolean", "default": false }
+  },
+  "required": ["name"]
+}

package/src/generators/formatting.d.ts

@@ -0,0 +1,8 @@
+import { type Tree } from '@nx/devkit';
+import { type Options as PrettierOptions } from 'prettier';
+export declare function changedTreePrettierOptions(tree: Tree): PrettierOptions | undefined;
+export declare function effectiveTreePrettierOptions(tree: Tree, path: string, changedOptions?: PrettierOptions): Promise<PrettierOptions>;
+export declare function formatTreeContentsToFixedPoint(contents: string, options: PrettierOptions, path: string): Promise<string>;
+export declare function formatTreeFileToFixedPoint(tree: Tree, path: string): Promise<void>;
+export declare function createTreeFileRestorer(tree: Tree, retain: (path: string) => boolean): () => void;
+export declare function formatChangedTreeToFixedPoint(tree: Tree, restoreProtectedFiles?: () => void): Promise<void>;

package/src/generators/formatting.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changedTreePrettierOptions = changedTreePrettierOptions;
+exports.effectiveTreePrettierOptions = effectiveTreePrettierOptions;
+exports.formatTreeContentsToFixedPoint = formatTreeContentsToFixedPoint;
+exports.formatTreeFileToFixedPoint = formatTreeFileToFixedPoint;
+exports.createTreeFileRestorer = createTreeFileRestorer;
+exports.formatChangedTreeToFixedPoint = formatChangedTreeToFixedPoint;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
+const prettier_1 = require("prettier");
+const yaml_1 = require("yaml");
+const preview_changes_js_1 = require("../developer-agent/preview-changes.js");
+const MAX_FORMAT_PASSES = 4;
+function changedTreePrettierOptions(tree) {
+    const changedPaths = new Set(tree.listChanges().map(({ path }) => path));
+    const candidates = [
+        'package.json',
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.yaml',
+        '.prettierrc.yml',
+    ];
+    for (const path of candidates) {
+        if (!changedPaths.has(path) &&
+            !(tree instanceof preview_changes_js_1.DeferredDeveloperAgentTree &&
+                tree.hasPendingChange(path)))
+            continue;
+        const contents = tree.read(path, 'utf8');
+        if (contents === null)
+            continue;
+        let parsed;
+        try {
+            parsed =
+                path.endsWith('.yaml') || path.endsWith('.yml')
+                    ? (0, yaml_1.parse)(contents)
+                    : JSON.parse(contents);
+        }
+        catch (error) {
+            throw new Error(`Workspace Prettier configuration is invalid at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (path === 'package.json') {
+            if (typeof parsed !== 'object' ||
+                parsed === null ||
+                Array.isArray(parsed) ||
+                !Object.prototype.hasOwnProperty.call(parsed, 'prettier')) {
+                continue;
+            }
+            parsed = parsed.prettier;
+        }
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            throw new Error(`Workspace Prettier configuration must be an object at ${path}.`);
+        }
+        return parsed;
+    }
+    return undefined;
+}
+async function effectiveTreePrettierOptions(tree, path, changedOptions = changedTreePrettierOptions(tree)) {
+    const systemPath = (0, node_path_1.resolve)(tree.root, path);
+    const resolvedOptions = (await (0, prettier_1.resolveConfig)(systemPath, { editorconfig: true })) ?? {};
+    return {
+        singleQuote: true,
+        ...resolvedOptions,
+        ...changedOptions,
+        filepath: systemPath,
+    };
+}
+async function formatTreeContentsToFixedPoint(contents, options, path) {
+    let current = contents;
+    for (let pass = 0; pass < MAX_FORMAT_PASSES; pass += 1) {
+        const formatted = await (0, prettier_1.format)(current, options);
+        if (formatted === current)
+            return current;
+        current = formatted;
+    }
+    throw new Error(`Prettier formatting did not converge for ${path}.`);
+}
+async function formatTreeFileToFixedPoint(tree, path) {
+    const contents = tree.read(path, 'utf8');
+    if (contents === null) {
+        throw new Error(`Generated file is missing at ${path}.`);
+    }
+    const options = await effectiveTreePrettierOptions(tree, path);
+    tree.write(path, await formatTreeContentsToFixedPoint(contents, options, path));
+}
+function createTreeFileRestorer(tree, retain) {
+    const files = new Map();
+    for (const { path, type } of tree.listChanges()) {
+        if (type === 'DELETE' || !retain(path) || files.has(path))
+            continue;
+        const contents = tree.read(path);
+        if (contents !== null)
+            files.set(path, contents);
+    }
+    return () => {
+        for (const [path, contents] of files)
+            tree.write(path, contents);
+    };
+}
+function changedTreeSnapshot(tree) {
+    const paths = [
+        ...new Set(tree
+            .listChanges()
+            .filter(({ type }) => type !== 'DELETE')
+            .map(({ path }) => path)),
+    ].sort();
+    return JSON.stringify(paths.map((path) => [path, tree.read(path)?.toString('base64') ?? null]));
+}
+async function formatChangedTreeToFixedPoint(tree, restoreProtectedFiles = () => undefined) {
+    for (let pass = 0; pass < MAX_FORMAT_PASSES; pass += 1) {
+        const before = changedTreeSnapshot(tree);
+        await (0, devkit_1.formatFiles)(tree);
+        // Nx sees only this transaction's changes, not pending configuration in
+        // an enclosing tree. Reapply that configuration without widening its diff.
+        const inheritedOptions = changedTreePrettierOptions(tree);
+        if (tree instanceof preview_changes_js_1.DeferredDeveloperAgentTree &&
+            inheritedOptions &&
+            process.env.NX_SKIP_FORMAT !== 'true') {
+            await Promise.all(tree.listChanges().map(async ({ path, type }) => {
+                if (type === 'DELETE')
+                    return;
+                const options = await effectiveTreePrettierOptions(tree, path, inheritedOptions);
+                if (path.endsWith('.swcrc'))
+                    options.parser = 'json';
+                const support = await (0, prettier_1.getFileInfo)((0, node_path_1.resolve)(tree.root, path), options);
+                if (support.ignored || !support.inferredParser)
+                    return;
+                const contents = tree.read(path, 'utf8');
+                if (contents !== null)
+                    tree.write(path, await formatTreeContentsToFixedPoint(contents, options, path));
+            }));
+        }
+        restoreProtectedFiles();
+        if (changedTreeSnapshot(tree) === before)
+            return;
+    }
+    throw new Error('Workspace formatting did not converge.');
+}
+//# sourceMappingURL=formatting.js.map