@loomweaver/cli 0.7.2 → 0.7.3

package/dist/main.mjs

@@ -12,6 +12,243 @@ function generate(recipe, input) {
   }
   return files;
 }
+function amendments(recipe, input) {
+  return recipe.amend?.(input) ?? [];
+}
+
+// ../devkit/src/lib/amend/merge.ts
+function joinProjectPath(projectRoot, path) {
+  const root = projectRoot.replace(/^\.?\/*/, "").replace(/\/+$/, "");
+  return root ? `${root}/${path}` : path;
+}
+function resolveAssetInput(glob, projectRoot) {
+  return glob.from === "project" ? joinProjectPath(projectRoot, glob.input) : glob.input;
+}
+function ensurePostcssPlugin(existing, amendment) {
+  const root = asObject(existing) ?? {};
+  const plugins = asObject(root["plugins"]);
+  if (plugins === void 0 && root["plugins"] !== void 0) {
+    return {
+      value: root,
+      added: [],
+      declined: [`${amendment.file}: "plugins" is not an object`]
+    };
+  }
+  const next = { ...plugins ?? {} };
+  if (amendment.plugin in next) {
+    return { value: root, added: [], declined: [] };
+  }
+  next[amendment.plugin] = {};
+  return {
+    value: { ...root, plugins: next },
+    added: [`${amendment.file}: ${amendment.plugin}`],
+    declined: []
+  };
+}
+function ensureBuildTarget(target, amendment, projectRoot) {
+  const next = { ...asObject(target) ?? {} };
+  const added = [];
+  const declined = [];
+  const options = { ...asObject(next["options"]) ?? {} };
+  const styles = ensureStrings(
+    options["styles"],
+    amendment.styles.map((style) => joinProjectPath(projectRoot, style))
+  );
+  if (styles.added.length > 0) {
+    options["styles"] = styles.value;
+    added.push(...styles.added.map((entry) => `styles: ${entry}`));
+  }
+  const assets = ensureAssets(options["assets"], amendment.assets, projectRoot);
+  if (assets.added.length > 0) {
+    options["assets"] = assets.value;
+    added.push(...assets.added.map((entry) => `assets: ${entry}`));
+  }
+  next["options"] = options;
+  if (amendment.inlineCritical !== void 0 || amendment.serviceWorker) {
+    const configurations = { ...asObject(next["configurations"]) ?? {} };
+    const production = { ...asObject(configurations["production"]) ?? {} };
+    if (amendment.serviceWorker && production["serviceWorker"] === void 0) {
+      production["serviceWorker"] = joinProjectPath(
+        projectRoot,
+        amendment.serviceWorker
+      );
+      added.push(`production serviceWorker: ${production["serviceWorker"]}`);
+    }
+    if (amendment.inlineCritical !== void 0) {
+      const critical = ensureInlineCritical(
+        production["optimization"],
+        amendment.inlineCritical
+      );
+      if (critical.declined) {
+        declined.push(
+          "production optimization is a boolean, so inlineCritical cannot be set beside it \u2014 a release build then loads the stylesheet with an inline handler the generated content-security policy blocks, and renders unstyled"
+        );
+      } else if (critical.changed) {
+        production["optimization"] = critical.value;
+        added.push(
+          `production optimization.styles.inlineCritical: ${amendment.inlineCritical}`
+        );
+      }
+    }
+    configurations["production"] = production;
+    next["configurations"] = configurations;
+  }
+  return { value: next, added, declined };
+}
+function ensureStylesheetSource(css, source) {
+  const quoted = source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`@source\\s+['"]${quoted}/?['"]`).test(css)) {
+    return css;
+  }
+  return `${css.trimEnd()}
+
+@source '${source}';
+`;
+}
+function ensureInlineCritical(optimization, inlineCritical) {
+  if (typeof optimization === "boolean") {
+    return { value: optimization, changed: false, declined: true };
+  }
+  const root = { ...asObject(optimization) ?? {} };
+  const styles = asObject(root["styles"]);
+  if (styles === void 0 && root["styles"] !== void 0) {
+    return { value: optimization, changed: false, declined: true };
+  }
+  if (styles?.["inlineCritical"] !== void 0) {
+    return { value: optimization, changed: false, declined: false };
+  }
+  return {
+    value: { ...root, styles: { ...styles ?? {}, inlineCritical } },
+    changed: true,
+    declined: false
+  };
+}
+function ensureStrings(existing, wanted) {
+  const list2 = Array.isArray(existing) ? [...existing] : [];
+  const added = [];
+  for (const entry of wanted) {
+    if (!list2.includes(entry)) {
+      list2.push(entry);
+      added.push(entry);
+    }
+  }
+  return { value: list2, added };
+}
+function ensureAssets(existing, wanted, projectRoot) {
+  const list2 = Array.isArray(existing) ? [...existing] : [];
+  const added = [];
+  for (const glob of wanted) {
+    const input = resolveAssetInput(glob, projectRoot);
+    if (list2.some((entry) => inputOf(entry) === input)) {
+      continue;
+    }
+    list2.push({
+      glob: glob.glob,
+      input,
+      ...glob.output === void 0 ? {} : { output: glob.output }
+    });
+    added.push(input);
+  }
+  return { value: list2, added };
+}
+function inputOf(entry) {
+  if (typeof entry === "string") {
+    return entry;
+  }
+  const asset = asObject(entry);
+  return typeof asset?.["input"] === "string" ? asset["input"] : void 0;
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+
+// ../devkit/src/lib/amend/compose.ts
+var PROVIDERS = /(export\s+const\s+appConfig\s*:[^=]*=\s*\{[\s\S]*?providers\s*:\s*\[)([\s\S]*?)(\n(\s*)\],)/;
+var SHELL_IMPORT = /import\s*\{([^}]*)\}\s*from\s*'@loomweaver\/shell';/;
+function composePlugin(source, amendment, importPath) {
+  if (source.includes(amendment.symbol)) {
+    return { source, composed: true };
+  }
+  const providers = PROVIDERS.exec(source);
+  const shellImport = SHELL_IMPORT.exec(source);
+  if (!providers || !shellImport) {
+    return { source, composed: false };
+  }
+  const withImports = source.replace(
+    SHELL_IMPORT,
+    `import {${withShellSymbols(shellImport[1])}} from '@loomweaver/shell';
+import { ${amendment.symbol} } from '${importPath}';`
+  );
+  const indent = `${providers[4]}  `;
+  const lines = [
+    `${indent}provideTranslationNamespaces('${amendment.id}'),`,
+    `${indent}provideCapabilityGrants({ ${amendment.id}: [${amendment.capabilities.map((capability) => `'${capability}'`).join(", ")}] }),`,
+    `${indent}...providePlugins(${amendment.symbol}),`
+  ].join("\n");
+  return {
+    source: withImports.replace(
+      PROVIDERS,
+      (_all, head, body, tail) => `${head}${body}
+${lines}${tail}`
+    ),
+    composed: true
+  };
+}
+function composeLines(amendment, importPath) {
+  return [
+    `import { ${amendment.symbol} } from '${importPath}';`,
+    "import { providePlugins, provideCapabilityGrants, provideTranslationNamespaces } from '@loomweaver/shell';",
+    `provideTranslationNamespaces('${amendment.id}'),`,
+    `provideCapabilityGrants({ ${amendment.id}: [${amendment.capabilities.map((capability) => `'${capability}'`).join(", ")}] }),`,
+    `...providePlugins(${amendment.symbol}),`
+  ];
+}
+function withShellSymbols(existing) {
+  const wanted = [
+    "provideCapabilityGrants",
+    "providePlugins",
+    "provideTranslationNamespaces"
+  ];
+  const present = existing.split(",").map((symbol) => symbol.trim()).filter(Boolean);
+  const missing = wanted.filter(
+    (symbol) => !present.some((entry) => entry.replace(/^type\s+/, "") === symbol)
+  );
+  if (missing.length === 0) {
+    return existing;
+  }
+  const multiline = existing.includes("\n");
+  const all = [...present, ...missing].sort((a, b) => a.localeCompare(b));
+  return multiline ? `
+  ${all.join(",\n  ")},
+` : ` ${all.join(", ")} `;
+}
+
+// ../devkit/src/lib/amend/describe.ts
+function describeAmendment(amendment) {
+  if (amendment.kind === "postcss") {
+    return `Write ${amendment.file} beside your package.json, naming ${amendment.plugin}. Without it the stylesheet is read as plain CSS: no utility class is emitted, the workbench renders unstyled, and the build still reports success.`;
+  }
+  if (amendment.kind === "stylesheet-source") {
+    return `Add an @source entry for '${amendment.sourceRoot}' to the application's entry stylesheet, resolved from that stylesheet. Without it none of that code's utilities are emitted.`;
+  }
+  if (amendment.kind === "compose-plugin") {
+    return `Register ${amendment.id} in the composition root: import { ${amendment.symbol} }, provideTranslationNamespaces('${amendment.id}'), provideCapabilityGrants({ ${amendment.id}: [${amendment.capabilities.map((capability) => `'${capability}'`).join(
+      ", "
+    )}] }) and ...providePlugins(${amendment.symbol}). Without it none of its contributions appear.`;
+  }
+  return [
+    ...amendment.styles.length > 0 ? [`name ${amendment.styles.join(", ")} in styles`] : [],
+    ...amendment.assets.length > 0 ? [
+      `add assets for ${amendment.assets.map((asset) => asset.input).join(", ")} (the shell fetches its own strings at runtime, so without that glob every label in the chrome renders as its raw translation key)`
+    ] : [],
+    ...amendment.serviceWorker ? [
+      `set serviceWorker to ${amendment.serviceWorker} in the production configuration (provideShell registers a worker that 404s otherwise)`
+    ] : [],
+    ...amendment.inlineCritical === void 0 ? [] : [
+      `set optimization.styles.inlineCritical to ${amendment.inlineCritical} in the production configuration (the generated content-security policy blocks the inline handler Angular's critical-CSS pass attaches, so a release build renders unstyled)`
+    ]
+  ].map((step, index) => `${index + 1}. ${step}`).join(" ");
+}
 
 // ../devkit/src/lib/generate/casing.ts
 function isKebabId(value) {
@@ -834,6 +1071,40 @@ var framePlugin = {
   }
 };
 
+// ../devkit/src/recipes/angular-distribution/amendments.ts
+function distributionAmendments(d) {
+  return [
+    ...d.styles === "tailwind" ? [
+      {
+        kind: "postcss",
+        file: ".postcssrc.json",
+        plugin: "@tailwindcss/postcss"
+      }
+    ] : [],
+    {
+      kind: "build-target",
+      styles: ["src/styles.css"],
+      assets: [
+        { glob: "**/*", input: "public", from: "project" },
+        {
+          glob: "**/*",
+          input: "node_modules/@loomweaver/shell/i18n",
+          from: "workspace",
+          output: "i18n"
+        },
+        {
+          glob: "**/*",
+          input: "node_modules/@loomweaver/frame-kit/dist",
+          from: "workspace",
+          output: "frame-kit"
+        }
+      ],
+      serviceWorker: "ngsw-config.json",
+      inlineCritical: false
+    }
+  ];
+}
+
 // ../devkit/src/recipes/shell-regions.ts
 var SHELL_REGIONS = [
   "{ id: 'top-bar', type: 'bar', dock: 'top' }",
@@ -1086,20 +1357,15 @@ function stylesNotes(d) {
   }
   return [
     "`src/styles.css` compiles the shell's source theme with Tailwind 4, which is also what lets you",
-    "write Tailwind utilities in your own templates. It needs two things the scaffold cannot add for",
-    "you \u2014 the packages:",
+    "write Tailwind utilities in your own templates. The scaffold wrote `.postcssrc.json` beside your",
+    "`package.json` for you, because without it the stylesheet is read as plain CSS: no utility class",
+    "is emitted, the workbench renders unstyled, and the build still reports success. The packages are",
+    "the one thing left, because a scaffold does not install:",
     "",
     "```sh",
     "npm install -D tailwindcss @tailwindcss/postcss @tailwindcss/typography",
     "```",
     "",
-    "and the PostCSS plugin, in a file next to your `package.json`:",
-    "",
-    "```jsonc",
-    "// .postcssrc.json",
-    '{ "plugins": { "@tailwindcss/postcss": {} } }',
-    "```",
-    "",
     "Use **semantic tokens only** in your own templates (`bg-surface`, `text-content`, `text-brand`,",
     "`border-border`), never raw palette colours.",
     "",
@@ -1185,39 +1451,25 @@ function readme2(d) {
     "",
     "## Build wiring",
     "",
-    "The Nx generator put all of this in `project.json`. Scaffolded over the CLI or MCP, add it to",
-    "your build target yourself \u2014 `angular.json` under `projects.<name>.architect.build.options` with",
-    "the Angular CLI, `project.json` under `targets.build.options` in Nx. Paths inside `assets` are",
-    "resolved from the workspace root, so they read the same either way:",
+    "The scaffold did this. Your build target now names the stylesheet, three asset globs, the",
+    "service worker and one production setting, and the run that wrote these files listed each one it",
+    "added. Anything you had already set was left exactly as you set it.",
     "",
-    "```jsonc",
-    '"styles": ["src/styles.css"],',
-    '"assets": [',
-    '  { "glob": "**/*", "input": "public" },',
-    '  { "glob": "**/*", "input": "node_modules/@loomweaver/shell/i18n", "output": "i18n" },',
-    '  { "glob": "**/*", "input": "node_modules/@loomweaver/frame-kit/dist", "output": "frame-kit" }',
-    "],",
-    '"serviceWorker": "ngsw-config.json"',
-    "```",
-    "",
-    "And in the **production** configuration of that same target:",
+    "What each is for, so that nobody removes one as clutter. The **`@loomweaver/shell/i18n` glob**",
+    "serves the strings the shell fetches at runtime; without it every label in the chrome renders as",
+    "its raw translation key and nothing errors. The **frame-kit** glob only matters if you host",
+    "sandboxed (iframe) plugins \u2014 until you install that package the glob simply matches nothing.",
+    "**`serviceWorker`** emits the worker that `provideShell()` already registers for you (inert in",
+    "dev) \u2014 never add `provideServiceWorker` yourself, and if you would rather ship no worker at all,",
+    "drop `ngsw-config.json` and pass `provideShell({ serviceWorker: false })`, because otherwise the",
+    "registration 404s in production. **`optimization.styles.inlineCritical: false`** is not optional:",
+    "the `index.html` above ships a strict `script-src 'self'`, and Angular's critical-CSS pass loads",
+    "the stylesheet with an **inline** `onload` handler that the policy blocks \u2014 the app then renders",
+    "completely unstyled, and only in production builds.",
     "",
-    "```jsonc",
-    '"optimization": { "styles": { "inlineCritical": false } }',
-    "```",
-    "",
-    "Each of those earns its place. The **`@loomweaver/shell/i18n` glob** is the one whose absence is easy",
-    "to misread: the shell fetches its own UI strings at runtime, so without it every label in the",
-    "chrome renders as its raw translation key and nothing errors. The **frame-kit** glob only",
-    "matters if you host sandboxed (iframe) plugins \u2014 install that package then; until you do, the",
-    "glob simply matches nothing. **`serviceWorker`** emits the worker that `provideShell()` already",
-    "registers for you (inert in dev) \u2014 never add `provideServiceWorker` yourself, and if you would",
-    "rather ship no worker at all, drop `ngsw-config.json` and pass",
-    "`provideShell({ serviceWorker: false })`, because otherwise the registration 404s in production.",
-    "**`inlineCritical: false`** is not optional here: the `index.html` above ships a strict",
-    "`script-src 'self'`, and Angular's critical-CSS pass loads the stylesheet with an **inline**",
-    "`onload` handler that the policy blocks \u2014 the app then renders completely unstyled, and only in",
-    "production builds.",
+    "One thing is still yours, because the scaffold cannot know your budget: a production build warns",
+    "that the initial bundle exceeds Angular's 500 kB default. The shell is a whole application",
+    "chrome, so raise the budgets in your build target.",
     "",
     "## Ship less than the whole workbench",
     "",
@@ -1256,6 +1508,9 @@ function readme2(d) {
 }
 var angularDistribution = {
   id: "angular-distribution",
+  amend(input) {
+    return distributionAmendments(resolveDistributionInput(input));
+  },
   build(input) {
     const d = resolveDistributionInput(input);
     return {
@@ -1546,6 +1801,67 @@ var layout = {
   }
 };
 
+// ../devkit/src/recipes/angular-weaver/amendments.ts
+function weaverAmendments(input, where) {
+  const w = resolveWeaverInput(input);
+  const directory = (where ?? "").replace(/^\.?\/*/, "").replace(/\/+$/, "");
+  if (!directory) {
+    return [];
+  }
+  return [
+    {
+      kind: "build-target",
+      styles: [],
+      assets: [
+        {
+          glob: "**/*.json",
+          input: `${directory}/src/lib/i18n`,
+          from: "workspace",
+          output: `i18n/${w.id}`
+        }
+      ]
+    },
+    { kind: "stylesheet-source", sourceRoot: `${directory}/src` },
+    {
+      kind: "compose-plugin",
+      id: w.id,
+      symbol: `${w.propertyName}Plugin`,
+      capabilities: w.capabilities,
+      sourceRoot: `${directory}/src`
+    }
+  ];
+}
+
+// ../devkit/src/lib/scaffolds/inputs.ts
+function weaverInput(values) {
+  return {
+    id: str(values, "id") ?? "",
+    name: str(values, "name"),
+    prefix: str(values, "prefix"),
+    importPath: str(values, "importPath"),
+    features: {
+      command: bool(values, "command"),
+      shortcut: str(values, "shortcut"),
+      menu: str(values, "menu"),
+      barItem: bool(values, "barItem"),
+      settings: bool(values, "settings"),
+      about: bool(values, "about"),
+      instanceable: bool(values, "instanceable"),
+      container: bool(values, "container"),
+      access: str(values, "access"),
+      spec: bool(values, "spec")
+    }
+  };
+}
+function distributionInput(values) {
+  return {
+    name: str(values, "name") ?? "",
+    title: str(values, "title"),
+    directory: str(values, "directory"),
+    styles: str(values, "styles") ?? "tailwind"
+  };
+}
+
 // ../devkit/src/lib/scaffolds/scaffolds.ts
 function str(values, name) {
   const value = values[name];
@@ -1684,24 +2000,8 @@ var SCAFFOLDS = [
       APP_OPTION,
       ...PLACEMENT_OPTIONS
     ],
-    build: (values) => generate(angularWeaver, {
-      id: str(values, "id") ?? "",
-      name: str(values, "name"),
-      prefix: str(values, "prefix"),
-      importPath: str(values, "importPath"),
-      features: {
-        command: bool(values, "command"),
-        shortcut: str(values, "shortcut"),
-        menu: str(values, "menu"),
-        barItem: bool(values, "barItem"),
-        settings: bool(values, "settings"),
-        about: bool(values, "about"),
-        instanceable: bool(values, "instanceable"),
-        container: bool(values, "container"),
-        access: str(values, "access"),
-        spec: bool(values, "spec")
-      }
-    })
+    build: (values) => generate(angularWeaver, weaverInput(values)),
+    amend: (values) => weaverAmendments(weaverInput(values), str(values, "directory"))
   },
   {
     name: "frame-plugin",
@@ -1757,12 +2057,8 @@ var SCAFFOLDS = [
       },
       ...PLACEMENT_OPTIONS
     ],
-    build: (values) => generate(angularDistribution, {
-      name: str(values, "name") ?? "",
-      title: str(values, "title"),
-      directory: str(values, "directory"),
-      styles: str(values, "styles") ?? "tailwind"
-    })
+    build: (values) => generate(angularDistribution, distributionInput(values)),
+    amend: (values) => amendments(angularDistribution, distributionInput(values))
   },
   {
     name: "auth-source",
@@ -2113,7 +2409,7 @@ function validateCatalog(catalog, known = KNOWN_CAPABILITIES) {
 }
 
 // src/lib/run.ts
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { join } from "node:path";
 
 // src/lib/args.ts
@@ -2203,8 +2499,336 @@ function boolFlag(args, name) {
   return value;
 }
 
+// src/lib/amend.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, posix, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// src/lib/workspace.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+var WorkspaceError = class extends Error {
+};
+function findWorkspace(from) {
+  let dir = resolve(from);
+  for (; ; ) {
+    if (existsSync(resolve(dir, "package.json"))) {
+      return { root: dir, ...buildConfigIn(dir) };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+function resolveBuildProject(workspace, target) {
+  const projects = readProjects(workspace);
+  if (projects.length === 0) {
+    throw new WorkspaceError(
+      `No project with a build target found in ${workspace.configFile ?? workspace.root}.`
+    );
+  }
+  const inside = projects.filter((project) => contains(project.root, relativeTo(workspace.root, target))).sort((a, b) => b.root.length - a.root.length);
+  if (inside.length > 0) {
+    return inside[0];
+  }
+  if (projects.length === 1) {
+    return projects[0];
+  }
+  throw new WorkspaceError(
+    `More than one project could be the target, so none was chosen: ${projects.map((project) => project.name).join(", ")}. Generate into the project's own directory.`
+  );
+}
+function readJsonFile(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new WorkspaceError(
+      `${file} is not valid JSON: ${error.message}`
+    );
+  }
+}
+function buildConfigIn(dir) {
+  const angular = resolve(dir, "angular.json");
+  if (existsSync(angular)) {
+    return { configFile: angular, kind: "angular" };
+  }
+  const nx = resolve(dir, "nx.json");
+  if (existsSync(nx)) {
+    return { configFile: nx, kind: "nx" };
+  }
+  return {};
+}
+function readProjects(workspace) {
+  if (workspace.kind !== "angular" || !workspace.configFile) {
+    return [];
+  }
+  const config = readJsonFile(workspace.configFile);
+  const projects = asObject2(asObject2(config)?.["projects"]) ?? {};
+  return Object.entries(projects).filter(([, project]) => hasBuildTarget(project)).map(([name, project]) => ({
+    name,
+    root: normalise(asObject2(project)?.["root"])
+  }));
+}
+function hasBuildTarget(project) {
+  const architect = asObject2(project)?.["architect"] ?? asObject2(project)?.["targets"];
+  return asObject2(architect)?.["build"] !== void 0;
+}
+function contains(projectRoot, target) {
+  return projectRoot === "" || target === projectRoot || target.startsWith(`${projectRoot}/`);
+}
+function relativeTo(root, target) {
+  return relative(root, resolve(target)).split(sep).join("/");
+}
+function normalise(value) {
+  return typeof value === "string" ? value.replace(/^\.?\/*/, "").replace(/\/+$/, "") : "";
+}
+function asObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+
+// src/lib/amend.ts
+var JS_POSTCSS_CONFIGS = [
+  "postcss.config.js",
+  "postcss.config.mjs",
+  "postcss.config.cjs",
+  ".postcssrc.js"
+];
+function planAmend(amendments2, target) {
+  if (amendments2.length === 0) {
+    return { amendments: [], remaining: [] };
+  }
+  const workspace = findWorkspace(target);
+  if (!workspace) {
+    return {
+      amendments: [],
+      remaining: [
+        `No workspace was found above the target directory, so nothing could be wired here. Add it by hand, or generate inside the workspace: ${amendments2.map(describeAmendment).join(" \xB7 ")}`
+      ]
+    };
+  }
+  return new Amender(workspace, target).plan(amendments2);
+}
+function applyAmend(plan) {
+  for (const amendment of plan.amendments) {
+    writeFileSync(amendment.file, amendment.content, "utf8");
+  }
+}
+var Amender = class {
+  constructor(workspace, target) {
+    this.workspace = workspace;
+    this.target = target;
+    this.planned = [];
+    this.remaining = [];
+    this.configAdded = [];
+  }
+  plan(amendments2) {
+    for (const amendment of amendments2) {
+      this.planOne(amendment);
+    }
+    this.flushConfig();
+    return { amendments: this.planned, remaining: this.remaining };
+  }
+  planOne(amendment) {
+    if (amendment.kind === "postcss") {
+      this.planPostcss(amendment);
+      return;
+    }
+    if (this.workspace.kind !== "angular") {
+      this.remaining.push(this.nonAngularNote(amendment));
+      return;
+    }
+    const project = this.resolveProject();
+    if (!project) {
+      return;
+    }
+    if (amendment.kind === "build-target") {
+      this.planBuildTarget(amendment, project);
+    } else if (amendment.kind === "stylesheet-source") {
+      this.planStylesheetSource(amendment, project);
+    } else {
+      this.planComposePlugin(amendment, project);
+    }
+  }
+  planPostcss(amendment) {
+    const inTheWay = JS_POSTCSS_CONFIGS.find(
+      (name) => existsSync2(resolve2(this.workspace.root, name))
+    );
+    if (inTheWay) {
+      this.remaining.push(
+        `${inTheWay} is written as code and cannot be merged into, so add ${amendment.plugin} to it yourself; until then the stylesheet emits no utility class and the workbench renders unstyled.`
+      );
+      return;
+    }
+    const file = resolve2(this.workspace.root, amendment.file);
+    const result = ensurePostcssPlugin(
+      existsSync2(file) ? readJsonFile(file) : void 0,
+      amendment
+    );
+    this.remaining.push(...result.declined);
+    if (result.added.length === 0) {
+      return;
+    }
+    this.planned.push({
+      file,
+      display: this.displayName(file),
+      added: result.added,
+      content: `${JSON.stringify(result.value, null, 2)}
+`
+    });
+  }
+  planBuildTarget(amendment, project) {
+    const target = this.buildTarget(project.name);
+    if (!target) {
+      this.remaining.push(
+        `${project.name} has no build target to wire, so add it by hand: ${describeAmendment(amendment)}.`
+      );
+      return;
+    }
+    const result = ensureBuildTarget(target.value, amendment, project.root);
+    this.remaining.push(...result.declined);
+    if (result.added.length === 0) {
+      return;
+    }
+    target.set(result.value);
+    this.configAdded.push(...result.added);
+  }
+  planStylesheetSource(amendment, project) {
+    const entry = this.entryStylesheet(project);
+    if (!entry || !existsSync2(entry)) {
+      this.remaining.push(
+        `No entry stylesheet is wired for ${project.name}, so add it yourself: ${describeAmendment(amendment)}.`
+      );
+      return;
+    }
+    const css = readFileSync2(entry, "utf8");
+    if (!/@import\s+['"]tailwindcss['"]/.test(css)) {
+      return;
+    }
+    const source = posix.relative(
+      this.displayName(dirname2(entry)),
+      amendment.sourceRoot
+    );
+    const next = ensureStylesheetSource(css, source);
+    if (next === css) {
+      return;
+    }
+    this.planned.push({
+      file: entry,
+      display: this.displayName(entry),
+      added: [`@source '${source}'`],
+      content: next
+    });
+  }
+  planComposePlugin(amendment, project) {
+    const root = resolve2(
+      this.workspace.root,
+      project.root,
+      "src/app/app.config.ts"
+    );
+    const importPath = relativeImport(
+      this.displayName(dirname2(root)),
+      amendment.sourceRoot
+    );
+    if (!existsSync2(root)) {
+      this.remaining.push(this.composeNote(amendment, importPath));
+      return;
+    }
+    const source = readFileSync2(root, "utf8");
+    const result = composePlugin(source, amendment, importPath);
+    if (!result.composed) {
+      this.remaining.push(this.composeNote(amendment, importPath));
+      return;
+    }
+    if (result.source === source) {
+      return;
+    }
+    this.planned.push({
+      file: root,
+      display: this.displayName(root),
+      added: [`${amendment.symbol}, its translations and its capability grants`],
+      content: result.source
+    });
+  }
+  composeNote(amendment, importPath) {
+    return `The composition root no longer presents the shape this scaffold generated, so ${amendment.id} was NOT registered and none of its contributions will appear. Add these to it yourself: ` + composeLines(amendment, importPath).join(" ");
+  }
+  flushConfig() {
+    if (this.configAdded.length === 0 || !this.config) {
+      return;
+    }
+    const file = this.workspace.configFile;
+    this.planned.push({
+      file,
+      display: this.displayName(file),
+      added: this.configAdded,
+      content: `${JSON.stringify(this.config, null, 2)}
+`
+    });
+  }
+  resolveProject() {
+    if (this.project) {
+      return this.project;
+    }
+    try {
+      this.project = resolveBuildProject(this.workspace, this.target);
+      return this.project;
+    } catch (error) {
+      this.remaining.push(error.message);
+      return void 0;
+    }
+  }
+  readConfig() {
+    this.config ??= readJsonFile(this.workspace.configFile);
+    return this.config;
+  }
+  buildTarget(name) {
+    const project = asObject3(asObject3(this.readConfig()["projects"])?.[name]);
+    if (!project) {
+      return void 0;
+    }
+    for (const key of ["architect", "targets"]) {
+      const targets = asObject3(project[key]);
+      if (targets?.["build"] !== void 0) {
+        return {
+          value: targets["build"],
+          set: (next) => {
+            targets["build"] = next;
+          }
+        };
+      }
+    }
+    return void 0;
+  }
+  entryStylesheet(project) {
+    const styles = asObject3(asObject3(this.buildTarget(project.name)?.value)?.["options"])?.["styles"];
+    if (!Array.isArray(styles)) {
+      return void 0;
+    }
+    const entry = styles.find(
+      (style) => typeof style === "string" && style.endsWith(".css")
+    );
+    return entry === void 0 ? void 0 : resolve2(this.workspace.root, entry);
+  }
+  nonAngularNote(amendment) {
+    const where = this.workspace.kind === "nx" ? "the project's own project.json" : "your build configuration";
+    return `This route wires an Angular CLI workspace only, so add ${describeAmendment(amendment)} to ${where} yourself. The Nx generator does it for you.`;
+  }
+  displayName(file) {
+    const inside = relative2(this.workspace.root, file).split(sep2).join("/");
+    return inside.startsWith("..") ? file : inside;
+  }
+};
+function asObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function relativeImport(fromDir, sourceRoot) {
+  const path = posix.relative(fromDir, sourceRoot);
+  return path.startsWith(".") ? path : `./${path}`;
+}
+
 // src/lib/scaffold.ts
-import { relative, resolve } from "node:path";
+import { relative as relative3, resolve as resolve3 } from "node:path";
 function findScaffold2(name) {
   const scaffold2 = findScaffold(name);
   if (!scaffold2) {
@@ -2256,23 +2880,28 @@ function valuesFor(scaffold2, args) {
   return values;
 }
 function directoryFromOut(out) {
-  const below = relative(process.cwd(), resolve(out ?? "."));
+  const below = relative3(process.cwd(), resolve3(out ?? "."));
   return below.startsWith("..") ? "" : below;
 }
-function buildScaffold(scaffold2, args) {
+function scaffoldValues(scaffold2, args) {
   const values = valuesFor(scaffold2, args);
   const takesDirectory = scaffold2.options.some(
     (option) => option.name === "directory"
   );
+  if (!takesDirectory) {
+    return values;
+  }
   const out = args.flags["out"];
-  return scaffold2.build(
-    takesDirectory ? {
-      ...values,
-      directory: directoryFromOut(
-        typeof out === "string" ? out : void 0
-      )
-    } : values
-  );
+  return {
+    ...values,
+    directory: directoryFromOut(typeof out === "string" ? out : void 0)
+  };
+}
+function buildScaffold(scaffold2, args) {
+  return scaffold2.build(scaffoldValues(scaffold2, args));
+}
+function amendmentsFor(scaffold2, args) {
+  return scaffold2.amend?.(scaffoldValues(scaffold2, args)) ?? [];
 }
 
 // src/lib/write.ts
@@ -2281,18 +2910,18 @@ import {
   mkdirSync,
   realpathSync,
   rmSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, isAbsolute, relative as relative4, resolve as resolve4 } from "node:path";
 var WriteError = class extends Error {
 };
 function planWrite(files, root) {
-  const absoluteRoot = resolve2(root);
+  const absoluteRoot = resolve4(root);
   const planned = [];
   const conflicts = [];
   for (const path of Object.keys(files).sort()) {
-    const absolute = resolve2(absoluteRoot, path);
-    const inside = relative2(absoluteRoot, absolute);
+    const absolute = resolve4(absoluteRoot, path);
+    const inside = relative4(absoluteRoot, absolute);
     if (inside.startsWith("..") || isAbsolute(inside)) {
       throw new WriteError(`Refusing to write outside the target directory: ${path}`);
     }
@@ -2305,10 +2934,10 @@ function planWrite(files, root) {
 }
 function applyWrite(files, plan) {
   for (const file of plan.files) {
-    mkdirSync(dirname(file.absolute), { recursive: true });
+    mkdirSync(dirname3(file.absolute), { recursive: true });
     assertResolvesInsideRoot(plan.root, file.path, file.absolute);
     replaceSymlinkEntry(file.absolute);
-    writeFileSync(file.absolute, files[file.path], "utf8");
+    writeFileSync2(file.absolute, files[file.path], "utf8");
   }
 }
 function entryExists(absolute) {
@@ -2320,7 +2949,7 @@ function entryExists(absolute) {
   }
 }
 function assertResolvesInsideRoot(root, path, absolute) {
-  const inside = relative2(realpathSync(root), realpathSync(dirname(absolute)));
+  const inside = relative4(realpathSync(root), realpathSync(dirname3(absolute)));
   if (inside.startsWith("..") || isAbsolute(inside)) {
     throw new WriteError(
       `Refusing to write through a link that leaves the target directory: ${path}`
@@ -2334,7 +2963,7 @@ function replaceSymlinkEntry(absolute) {
 }
 
 // src/lib/run.ts
-var VERSION = "0.7.2";
+var VERSION = "0.7.3";
 function help() {
   const commands = SCAFFOLDS.map((s) => `  ${s.name.padEnd(16)}${s.summary}`);
   return [
@@ -2406,7 +3035,7 @@ function readBundles(dir) {
     }
     const language = entry.slice(0, -".json".length);
     try {
-      bundles[language] = JSON.parse(readFileSync(join(dir, entry), "utf8"));
+      bundles[language] = JSON.parse(readFileSync3(join(dir, entry), "utf8"));
     } catch (error) {
       throw new ArgError(`${entry} is not valid JSON: ${error.message}`);
     }
@@ -2427,7 +3056,7 @@ function validateI18nCommand(args, io) {
 function readCatalog(file) {
   let raw;
   try {
-    raw = readFileSync(file, "utf8");
+    raw = readFileSync3(file, "utf8");
   } catch (error) {
     throw new ArgError(`Cannot read ${file}: ${error.message}`);
   }
@@ -2445,6 +3074,21 @@ function validateCatalogCommand(args, io) {
     boolFlag(args, "strict") === true
   );
 }
+function reportAmendments(io, amend, done) {
+  if (amend.amendments.length > 0) {
+    io.out(
+      done ? `Wired ${amend.amendments.length} workspace file(s):` : `Would wire ${amend.amendments.length} workspace file(s):`
+    );
+    for (const amendment of amend.amendments) {
+      io.out(`  ${amendment.display}`);
+      amendment.added.forEach((entry) => io.out(`    + ${entry}`));
+    }
+  }
+  if (amend.remaining.length > 0) {
+    io.out("Still to do by hand:");
+    amend.remaining.forEach((entry) => io.out(`  - ${entry}`));
+  }
+}
 function scaffold(args, io) {
   const descriptor = findScaffold2(args.command);
   rejectUnknownFlags(args, [
@@ -2454,8 +3098,10 @@ function scaffold(args, io) {
     "force"
   ]);
   const files = buildScaffold(descriptor, args);
-  const plan = planWrite(files, stringFlag(args, "out") ?? ".");
+  const out = stringFlag(args, "out") ?? ".";
+  const plan = planWrite(files, out);
   const paths = plan.files.map((file) => file.path);
+  const amend = planAmend(amendmentsFor(descriptor, args), out);
   if (boolFlag(args, "dry-run")) {
     io.out(`Would write ${paths.length} file(s) into ${plan.root}:`);
     paths.forEach((path) => io.out(`  ${path}`));
@@ -2465,6 +3111,7 @@ function scaffold(args, io) {
       );
       plan.conflicts.forEach((path) => io.out(`  ${path}`));
     }
+    reportAmendments(io, amend, false);
     return 0;
   }
   if (plan.conflicts.length > 0 && !boolFlag(args, "force")) {
@@ -2475,8 +3122,10 @@ function scaffold(args, io) {
     return 1;
   }
   applyWrite(files, plan);
+  applyAmend(amend);
   io.out(`Wrote ${paths.length} file(s) into ${plan.root}:`);
   paths.forEach((path) => io.out(`  ${path}`));
+  reportAmendments(io, amend, true);
   return 0;
 }
 function run(argv, io) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loomweaver/cli",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "LoomWeaver scaffolding CLI: generates weavers, distributions and integrations into any project — no Nx workspace, no LoomWeaver checkout and no AI assistant required.",
   "keywords": [
     "loomweaver",