@clearlydev/nx-archweave 0.3.2 → 0.3.3

package/dist/generators/_chunks/chunk-JHRTVURZ.js

@@ -0,0 +1,189 @@
+import {
+  composeReviewSetup,
+  judgeReviewFileConflict
+} from "./chunk-67INEVWL.js";
+import {
+  DEPENDABOT_PATH,
+  renderAddReviewReport,
+  renderLineDiff
+} from "./chunk-3A6RZUCZ.js";
+import {
+  generatorFilesDir,
+  renderTemplateFiles
+} from "./chunk-YNMLB4DL.js";
+import {
+  resolveDryRun
+} from "./chunk-TUN34LAQ.js";
+import {
+  applyJsonEdits,
+  treePackageManager
+} from "./chunk-EXYZLL7A.js";
+
+// src/generators/add-review/generator.ts
+var CONFIG_PATH = "toolkit.config.json";
+function deriveAltWorkflowPath(mainWorkflowPath) {
+  return mainWorkflowPath.replace(/\.yml$/, ".archweave.yml");
+}
+function readConfig(tree) {
+  const raw = tree.read(CONFIG_PATH, "utf-8");
+  if (raw === null) return { raw: null, parsed: null, error: null };
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { raw, parsed: null, error: `${CONFIG_PATH} must contain a top-level JSON object` };
+    }
+    return { raw, parsed, error: null };
+  } catch {
+    return { raw, parsed: null, error: `${CONFIG_PATH} is not valid JSON` };
+  }
+}
+function resolveLocale(option, config) {
+  if (option) return option;
+  const fromConfig = config.parsed?.["locale"];
+  return fromConfig === "ko" || fromConfig === "en" ? fromConfig : "en";
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, index) => deepEqual(value, b[index]));
+  }
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length || aKeys.some((key, index) => key !== bKeys[index])) return false;
+  return aKeys.every((key) => deepEqual(a[key], b[key]));
+}
+var PROVIDERS = ["claude", "gemini", "gpt", "cursor"];
+var BETA_PROVIDERS = ["gemini", "gpt", "cursor"];
+var MODES = ["fast", "standard", "thorough"];
+function recordedReview(config) {
+  const review = config?.["review"];
+  if (typeof review !== "object" || review === null || Array.isArray(review)) return {};
+  const record = review;
+  const pick = (value, allowed) => typeof value === "string" && allowed.includes(value) ? value : void 0;
+  const rounds = record["maxRounds"];
+  return {
+    provider: pick(record["provider"], PROVIDERS),
+    mode: pick(record["mode"], MODES),
+    maxRounds: rounds === 1 || rounds === 2 || rounds === 3 || rounds === 4 || rounds === 5 ? rounds : void 0
+  };
+}
+function runAddReview(tree, options) {
+  const config = readConfig(tree);
+  const detectedPm = treePackageManager(tree, config.parsed);
+  const packageManager = options.packageManager ?? detectedPm ?? "pnpm";
+  const packageManagerNote = options.packageManager === void 0 && detectedPm === null ? "the package manager could not be detected (no pnpm, yarn, bun or npm lockfile) \u2014 the workflow was rendered for pnpm; re-run with --packageManager=npm|yarn|bun if that is wrong." : void 0;
+  const recorded = recordedReview(config.parsed);
+  const provider = options.provider ?? recorded.provider ?? "claude";
+  const plan = composeReviewSetup({
+    enabled: true,
+    provider,
+    mode: options.mode ?? recorded.mode ?? "standard",
+    locale: resolveLocale(options.locale, config),
+    maxRounds: options.maxRounds ?? recorded.maxRounds ?? 3,
+    packageManager
+  });
+  if (plan === null) throw new Error("unreachable: add-review always composes with enabled: true");
+  if (config.error !== null) {
+    return {
+      dryRun: options.dryRun ?? false,
+      workflowPath: plan.workflowFilePath,
+      workflowAction: "aborted",
+      configAction: "aborted",
+      requiredSecretName: plan.requiredSecretName,
+      diff: null,
+      workflowYaml: null,
+      configSnippetJson: null,
+      configError: config.error,
+      dependabot: "not-applied",
+      dependabotProposal: null
+    };
+  }
+  const existing = tree.read(plan.workflowFilePath, "utf-8");
+  const verdict = judgeReviewFileConflict(existing, plan.workflowYaml);
+  let workflowAction;
+  let workflowPath = plan.workflowFilePath;
+  let writeWorkflowTo = null;
+  let diff = null;
+  let mainFileMatchesOptions;
+  if (verdict.kind === "create") {
+    workflowAction = "created";
+    writeWorkflowTo = plan.workflowFilePath;
+    mainFileMatchesOptions = true;
+  } else if (verdict.kind === "unchanged") {
+    workflowAction = "unchanged";
+    mainFileMatchesOptions = true;
+  } else {
+    switch (options.onConflict) {
+      case "overwrite":
+        workflowAction = "overwritten";
+        writeWorkflowTo = plan.workflowFilePath;
+        mainFileMatchesOptions = true;
+        break;
+      case "skip":
+        workflowAction = "skipped";
+        mainFileMatchesOptions = false;
+        break;
+      case "alternate-filename": {
+        const altWorkflowPath = deriveAltWorkflowPath(plan.workflowFilePath);
+        workflowAction = "alternate";
+        workflowPath = altWorkflowPath;
+        writeWorkflowTo = altWorkflowPath;
+        mainFileMatchesOptions = false;
+        break;
+      }
+      default:
+        workflowAction = "proposed";
+        diff = renderLineDiff(verdict.existing, verdict.generated);
+        mainFileMatchesOptions = false;
+    }
+  }
+  let configAction;
+  let newConfigContent = null;
+  if (!mainFileMatchesOptions) {
+    configAction = "not-updated";
+  } else {
+    const existingReview = config.parsed?.["review"];
+    if (deepEqual(existingReview, plan.configSnippet)) {
+      configAction = "unchanged";
+    } else {
+      configAction = config.raw === null ? "created" : "updated";
+      newConfigContent = applyJsonEdits(config.raw, [[["review"], plan.configSnippet]]);
+    }
+  }
+  const [dependabotFile] = renderTemplateFiles(generatorFilesDir("add-review", import.meta.url), ".github", {});
+  const existingDependabot = tree.read(DEPENDABOT_PATH, "utf-8");
+  const dependabot = existingDependabot === null ? "created" : /github-actions/.test(existingDependabot) ? "present" : "proposed";
+  const dryRun = options.dryRun ?? false;
+  if (!dryRun) {
+    if (writeWorkflowTo !== null) tree.write(writeWorkflowTo, plan.workflowYaml);
+    if (newConfigContent !== null) tree.write(CONFIG_PATH, newConfigContent);
+    if (dependabot === "created") tree.write(DEPENDABOT_PATH, dependabotFile.content);
+  }
+  return {
+    dryRun,
+    workflowPath,
+    workflowAction,
+    configAction,
+    requiredSecretName: plan.requiredSecretName,
+    diff,
+    workflowYaml: dryRun ? plan.workflowYaml : null,
+    configSnippetJson: dryRun ? JSON.stringify(plan.configSnippet, null, 2) : null,
+    configError: null,
+    dependabot,
+    dependabotProposal: dependabot === "proposed" ? dependabotFile.content : null,
+    ...packageManagerNote !== void 0 ? { packageManagerNote } : {},
+    ...BETA_PROVIDERS.includes(provider) ? { betaProvider: provider } : {}
+  };
+}
+async function addReviewGenerator(tree, options) {
+  console.log(renderAddReviewReport(runAddReview(tree, { ...options, dryRun: resolveDryRun(options) })));
+}
+var generator_default = addReviewGenerator;
+
+export {
+  recordedReview,
+  runAddReview,
+  addReviewGenerator,
+  generator_default
+};

package/dist/generators/_chunks/chunk-L2RZ2LBO.js

@@ -0,0 +1,132 @@
+import {
+  maskComments
+} from "./chunk-6ZTIUBB2.js";
+
+// ../templates/dist/fsd/fsd-eslint.js
+var FSD_ESLINT_MODULE = "@clearlydev/nx-archweave/eslint";
+function buildFsdEslintImportLine() {
+  return `import { fsdBoundaries } from '${FSD_ESLINT_MODULE}';`;
+}
+function buildFsdEslintEntry(severity, root = "src", framework = {}) {
+  const list = (key, values) => values === void 0 || values.length === 0 ? "" : `, ${key}: [${values.map((value) => `'${value}'`).join(", ")}]`;
+  return `...fsdBoundaries({ severity: '${severity}', cwd: import.meta.dirname, root: '${root}'${list("platformSuffixes", framework.platformSuffixes)}${list("routerDirs", framework.routerDirs)} }),`;
+}
+function buildFsdEslintSnippet({ severity, locale, root, framework }) {
+  const lines = locale === "ko" ? [
+    "// nx-archweave FSD \uB808\uC774\uC5B4 \uADDC\uCE59 \u2014 \uD504\uB860\uD2B8\uC5D4\uB4DC \uC571\uC758 eslint.config.mjs\uC5D0 \uC9C1\uC811 \uB123\uC73C\uC138\uC694:",
+    "// 1) \uB9C8\uC9C0\uB9C9 import \uB4A4\uC5D0 \uC544\uB798 import\uB97C,",
+    "// 2) \uC124\uC815 \uBC30\uC5F4(export default [...], \uB610\uB294 export default \uD558\uB294 \uBCC0\uC218\uC758 \uBC30\uC5F4)\uC758 \uB9C8\uC9C0\uB9C9 \uD56D\uBAA9\uC73C\uB85C \uC544\uB798 spread\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4."
+  ] : [
+    "// nx-archweave FSD layer rules \u2014 add these to the frontend app's eslint.config.mjs yourself:",
+    "// 1) the import after the last import,",
+    "// 2) the spread as the last element of the config array (export default [...], or the array your config exports by name)."
+  ];
+  return [...lines, buildFsdEslintImportLine(), buildFsdEslintEntry(severity, root, framework)].join("\n");
+}
+var LAYER_GUIDE_EN = {
+  app: "composition root: providers, routing, global styles (the framework entry point lives here)",
+  pages: "one slice per screen, composed from the layers below",
+  features: "one slice per user-facing capability (add-to-cart, sign-in)",
+  entities: "one slice per business object (user, product)",
+  shared: "segments, not slices: ui, api, lib, model, config \u2014 named by purpose"
+};
+var LAYER_GUIDE_KO = {
+  app: "\uC870\uD569 \uB8E8\uD2B8: providers, \uB77C\uC6B0\uD305, \uC804\uC5ED \uC2A4\uD0C0\uC77C (\uD504\uB808\uC784\uC6CC\uD06C \uC9C4\uC785\uC810\uC774 \uC5EC\uAE30 \uC788\uC74C)",
+  pages: "\uD654\uBA74 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 \u2014 \uC544\uB798 \uB808\uC774\uC5B4\uB4E4\uC744 \uC870\uD569",
+  features: "\uC0AC\uC6A9\uC790 \uAE30\uB2A5 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 (add-to-cart, sign-in)",
+  entities: "\uBE44\uC988\uB2C8\uC2A4 \uAC1D\uCCB4 \uD558\uB098\uB2F9 \uC2AC\uB77C\uC774\uC2A4 \uD558\uB098 (user, product)",
+  shared: "\uC2AC\uB77C\uC774\uC2A4\uAC00 \uC544\uB2C8\uB77C \uC138\uADF8\uBA3C\uD2B8: ui, api, lib, model, config \u2014 \uBAA9\uC801\uC73C\uB85C \uC774\uB984 \uC9D3\uAE30"
+};
+function buildFsdLayerGuide({ layers, directories, sourceRoot, locale }) {
+  const guide = locale === "ko" ? LAYER_GUIDE_KO : LAYER_GUIDE_EN;
+  const width = Math.max(...directories.map((d) => d.length));
+  const rows = layers.map((layer, index) => `  ${sourceRoot}/${directories[index].padEnd(width)}  ${guide[layer] ?? ""}`);
+  const footer = locale === "ko" ? [
+    "\uB808\uC774\uC5B4 \uD3F4\uB354\uB294 \uCCAB \uC2AC\uB77C\uC774\uC2A4\uAC00 \uC0DD\uAE38 \uB54C \uB9CC\uB4E4\uC5B4\uC9D1\uB2C8\uB2E4 (\uC815\uC2DD FSD):",
+    "  nx g @clearlydev/nx-archweave:feature --name=<name>   (page, entity, shared\uB3C4 \uAC19\uC740 \uBC29\uC2DD; --segments=ui,api)",
+    "  widgets/ \uB808\uC774\uC5B4\uB294 \uAE30\uBCF8 \uBC94\uC704 \uBC16\uC774\uC9C0\uB9CC nx g @clearlydev/nx-archweave:widget \uC73C\uB85C \uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
+    "\uC704\uC5D0\uC11C \uC544\uB798\uB85C\uB9CC import\uD560 \uC218 \uC788\uACE0, \uAC19\uC740 \uB808\uC774\uC5B4\uC758 \uC2AC\uB77C\uC774\uC2A4\uB07C\uB9AC\uB294 import\uD558\uC9C0 \uC54A\uC73C\uBA70, \uC2AC\uB77C\uC774\uC2A4\uB294",
+    "index.ts\uB97C \uD1B5\uD574\uC11C\uB9CC import\uD569\uB2C8\uB2E4 \u2014 archweave/fsd-boundaries ESLint \uADDC\uCE59\uC774 \uC704\uBC18\uC744 \uC54C\uB824 \uC90D\uB2C8\uB2E4."
+  ] : [
+    "Layer directories appear with their first slice (canonical FSD):",
+    "  nx g @clearlydev/nx-archweave:feature --name=<name>   (page, entity and shared work the same way; --segments=ui,api)",
+    "  widgets/ is outside the default scope but one command away: nx g @clearlydev/nx-archweave:widget",
+    "Imports go downward only, slices on one layer never import each other, and a slice is",
+    "imported through its index.ts \u2014 the archweave/fsd-boundaries ESLint rule reports violations."
+  ];
+  return [...rows, ...footer].join("\n");
+}
+
+// ../template-engine/dist/fsd/fsd-eslint-config.js
+function classifyFsdEslintConfig(configText) {
+  return maskComments(configText).includes(FSD_ESLINT_MODULE) ? "applied" : "absent";
+}
+var EXPORT_DEFAULT_ARRAY = /export\s+default\s+\[/g;
+var IMPORT_STATEMENT = /^import\b[^;]*?\bfrom\s+['"][^'"]+['"]\s*;?[ \t]*$/gm;
+var CLOSING_BRACKET = /\]\s*;?\s*$/;
+function closingBracketOf(masked, open) {
+  let depth = 0;
+  for (let i = open; i < masked.length; i++) {
+    const ch = masked[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      for (i++; i < masked.length && masked[i] !== ch; i++)
+        if (masked[i] === "\\")
+          i++;
+      continue;
+    }
+    if (ch === "[")
+      depth++;
+    else if (ch === "]" && --depth === 0)
+      return i;
+  }
+  return -1;
+}
+function namedConfigArrayEnd(masked) {
+  const exported = [...masked.matchAll(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/g)];
+  if (exported.length !== 1)
+    return -1;
+  const declaration = new RegExp(`(?:const|let|var)\\s+${exported[0][1].replace(/\$/g, "\\$")}\\s*=\\s*(?:defineConfig\\s*\\(\\s*)?\\[`).exec(masked);
+  if (declaration === null)
+    return -1;
+  return closingBracketOf(masked, declaration.index + declaration[0].length - 1);
+}
+function applyFsdEslintConfig(configText, severity, root = "src", framework = {}) {
+  if (classifyFsdEslintConfig(configText) === "applied")
+    return { status: "already-applied" };
+  const masked = maskComments(configText);
+  EXPORT_DEFAULT_ARRAY.lastIndex = 0;
+  const exportMatches = masked.match(EXPORT_DEFAULT_ARRAY) ?? [];
+  const closing = CLOSING_BRACKET.exec(masked);
+  const closingIndex = exportMatches.length === 1 && closing !== null ? closing.index : namedConfigArrayEnd(masked);
+  if (closingIndex === -1)
+    return { status: "unrecognized" };
+  const eol = configText.includes("\r\n") ? "\r\n" : "\n";
+  const before = configText.slice(0, closingIndex);
+  const lastNonSpace = before.replace(/\s+$/, "");
+  const needsComma = !lastNonSpace.endsWith(",") && !lastNonSpace.endsWith("[");
+  const entryText = `${needsComma ? "," : ""}${eol}  ${buildFsdEslintEntry(severity, root, framework)}${eol}`;
+  const withEntry = `${lastNonSpace}${entryText}${configText.slice(closingIndex)}`;
+  IMPORT_STATEMENT.lastIndex = 0;
+  let lastImportEnd = -1;
+  const maskedWithEntry = maskComments(withEntry);
+  for (let m = IMPORT_STATEMENT.exec(maskedWithEntry); m !== null; m = IMPORT_STATEMENT.exec(maskedWithEntry)) {
+    lastImportEnd = m.index + m[0].length;
+  }
+  const importLine = buildFsdEslintImportLine();
+  const text = lastImportEnd === -1 ? `${importLine}${eol}${eol}${withEntry}` : `${withEntry.slice(0, lastImportEnd)}${eol}${importLine}${withEntry.slice(lastImportEnd)}`;
+  return { status: "applied", text };
+}
+function buildFsdEslintPasteSnippet(severity, locale, root = "src", framework = {}) {
+  return buildFsdEslintSnippet({ severity, locale, root, framework });
+}
+function composeFsdLayerGuide({ profile, sourceRoot, locale }) {
+  const layers = [...profile.layers];
+  return buildFsdLayerGuide({ layers, directories: layers.map((layer) => profile.layerDirs[layer] ?? layer), sourceRoot, locale });
+}
+
+export {
+  classifyFsdEslintConfig,
+  applyFsdEslintConfig,
+  buildFsdEslintPasteSnippet,
+  composeFsdLayerGuide
+};

package/dist/generators/_chunks/chunk-MQNQJOWA.js

@@ -0,0 +1,217 @@
+import {
+  globToRegExp,
+  resolveFsdPolicy
+} from "./chunk-5MI3O4VZ.js";
+
+// src/eslint/fsd-boundaries.ts
+import { posix, relative, resolve, sep } from "node:path";
+
+// src/eslint/slice-groups.ts
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var SEGMENTS = [
+  "ui",
+  "model",
+  "api",
+  "lib",
+  "config",
+  "components",
+  "hooks",
+  "types",
+  "utils",
+  "helpers",
+  "constants",
+  "consts",
+  "store",
+  "stores",
+  "styles",
+  "assets",
+  "services",
+  "context"
+];
+var IGNORED = /^(\.|readme(\.|$))/i;
+var listings = /* @__PURE__ */ new Map();
+function list(dir) {
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(dir).mtimeMs;
+  } catch {
+    listings.delete(dir);
+    return null;
+  }
+  const cached = listings.get(dir);
+  if (cached !== void 0 && cached.mtimeMs === mtimeMs) return cached.entries;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({ name: entry.name, directory: entry.isDirectory() }));
+    listings.set(dir, { mtimeMs, entries });
+    return entries;
+  } catch {
+    return null;
+  }
+}
+function createGroupDetector(rootAbsolute, policy, isIndexFile, listDirectory = list) {
+  const groups = policy.sliceGroups;
+  if (groups === false) return () => false;
+  const segments = /* @__PURE__ */ new Set([...SEGMENTS, ...policy.segments]);
+  return (layerDir, name) => {
+    const key = `${layerDir}/${name}`;
+    if (groups.include.includes(key)) return true;
+    if (groups.exclude.includes(key) || !groups.auto) return false;
+    const entries = listDirectory(join(rootAbsolute, layerDir, name))?.filter((entry) => !IGNORED.test(entry.name)) ?? null;
+    if (entries === null || entries.length === 0) return false;
+    if (entries.some((entry) => !entry.directory || segments.has(entry.name))) return false;
+    return entries.some((entry) => listDirectory(join(rootAbsolute, layerDir, name, entry.name))?.some((child) => !child.directory && isIndexFile(child.name)) ?? false);
+  };
+}
+
+// src/eslint/fsd-boundaries.ts
+var LAYER_ORDER = ["app", "pages", "widgets", "features", "entities", "shared"];
+var LAYER_BY_DIR = {
+  app: "app",
+  _app: "app",
+  pages: "pages",
+  _pages: "pages",
+  widgets: "widgets",
+  features: "features",
+  entities: "entities",
+  shared: "shared"
+};
+var SLICED_LAYERS = /* @__PURE__ */ new Set(["pages", "widgets", "features", "entities"]);
+function indexFilePattern(platformSuffixes) {
+  const platforms = platformSuffixes.length === 0 ? "" : `(\\.(${platformSuffixes.map((suffix) => suffix.replace(/[^a-z0-9-]/gi, "")).join("|")}))?`;
+  return new RegExp(`^index${platforms}(\\.[cm]?[jt]sx?)?$`);
+}
+var DEFAULT_POLICY = resolveFsdPolicy(void 0);
+var NO_GROUPS = () => false;
+function locate(rootRelativePath, policy = DEFAULT_POLICY, isGroup = NO_GROUPS) {
+  const segments = rootRelativePath.split("/").filter((s) => s.length > 0 && s !== ".");
+  if (segments.length === 0) return null;
+  const layer = policy.routerDirs.includes(segments[0]) ? "app" : LAYER_BY_DIR[segments[0]];
+  if (layer === void 0) return null;
+  let unit;
+  let rest;
+  if (layer === "app") {
+    unit = null;
+    rest = segments.slice(1);
+  } else if (layer === "shared") {
+    const component = policy.sharedPublicApi === "component" && segments.length > 2;
+    unit = segments[1] === void 0 ? null : component ? `${segments[1]}/${segments[2]}` : segments[1];
+    rest = policy.sharedPublicApi === "file" ? [] : segments.slice(component ? 3 : 2);
+  } else if (segments[1] !== void 0 && isGroup(segments[0], segments[1])) {
+    if (segments[2] === void 0) return { layer, unit: segments[1], rest: [], group: true };
+    unit = `${segments[1]}/${segments[2]}`;
+    rest = segments.slice(3);
+  } else {
+    unit = segments[1] ?? null;
+    rest = segments.slice(2);
+  }
+  if (rest.length > 0 && indexFilePattern(policy.platformSuffixes).test(rest[rest.length - 1])) rest.pop();
+  return { layer, unit, rest };
+}
+function judge(from, to) {
+  if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer)) return { kind: "upward", from, to };
+  if (to.unit === null) return null;
+  if (to.group) return { kind: "group", from, to };
+  const sameUnit = from.layer === to.layer && from.unit === to.unit;
+  if (sameUnit) return null;
+  const importerSlice = from.unit?.split("/").pop();
+  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === importerSlice && from.layer === to.layer;
+  if (viaCrossImportApi) return null;
+  if (from.layer === to.layer && SLICED_LAYERS.has(to.layer)) return { kind: "cross-slice", from, to };
+  if (to.rest.length > 0) return { kind: "sidestep", from, to };
+  return null;
+}
+function describeLocation(location) {
+  return location.unit === null ? location.layer : `${location.layer}/${location.unit}`;
+}
+function resolveSpecifier(specifier, importerRootRelative, options) {
+  let rootRelative = null;
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    rootRelative = posix.normalize(posix.join(posix.dirname(importerRootRelative), specifier));
+  } else {
+    for (const [prefix, target] of Object.entries(options.aliases)) {
+      if (!specifier.startsWith(prefix)) continue;
+      const absolute = resolve(resolve(options.cwd, target), specifier.slice(prefix.length));
+      rootRelative = toPosix(relative(options.rootAbsolute, absolute)) || ".";
+      break;
+    }
+  }
+  if (rootRelative === null) return null;
+  if (rootRelative === ".." || rootRelative.startsWith("../")) return null;
+  return rootRelative;
+}
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+var fsdBoundariesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce canonical Feature-Sliced Design import rules inside a frontend app",
+      url: "https://github.com/clearlydev/nx-archweave#fsd-lite"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          root: { type: "string" },
+          aliases: { type: "object", additionalProperties: { type: "string" } },
+          policy: { type: "object" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
+      crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" \u2014 move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
+      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".',
+      group: 'FSD: "{{to}}" is a group of slices, not a slice \u2014 import one of its slices through its index.ts.'
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const root = options.root ?? "src";
+    const aliases = options.aliases ?? { "@/": root };
+    const cwd = context.cwd;
+    const rootAbsolute = resolve(cwd, root);
+    const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
+    if (importerRootRelative === "" || importerRootRelative.startsWith("..")) return {};
+    const policy = resolveFsdPolicy(void 0, options.policy ?? {});
+    const isIndexFile = (name) => indexFilePattern(policy.platformSuffixes).test(name);
+    const isGroup = createGroupDetector(rootAbsolute, policy, isIndexFile);
+    const from = locate(importerRootRelative, policy, isGroup);
+    if (from === null) return {};
+    const isTestFile = policy.testFiles !== false && policy.testFiles.some((glob) => globToRegExp(glob).test(importerRootRelative));
+    const check = (node, specifier) => {
+      if (typeof specifier !== "string") return;
+      const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
+      if (target === null) return;
+      const to = locate(target, policy, isGroup);
+      if (to === null) return;
+      const violation = judge(from, to);
+      if (violation === null || isTestFile && violation.kind !== "upward") return;
+      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit?.split("/").pop() ?? "", path: target };
+      context.report({
+        node,
+        messageId: violation.kind === "cross-slice" ? "crossSlice" : violation.kind,
+        data
+      });
+    };
+    const fromSource = (node) => check(node, node.source?.value);
+    return {
+      ImportDeclaration: fromSource,
+      ExportNamedDeclaration: fromSource,
+      ExportAllDeclaration: fromSource,
+      ImportExpression: (node) => {
+        const argument = node.source;
+        if (argument && argument.type === "Literal") check(node, argument.value);
+      }
+    };
+  }
+};
+
+export {
+  createGroupDetector,
+  indexFilePattern,
+  fsdBoundariesRule
+};