create-next-pro-cli 0.1.31 → 0.1.32

package/dist/bin.node.js

@@ -6,14 +6,124 @@ import path10 from "path";
 // src/cli/completion.ts
 import path2 from "path";
 
+// src/core/contracts.ts
+var CliError = class extends Error {
+  exitCode;
+  code;
+  hint;
+  scope;
+  path;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    if (typeof options === "number") {
+      this.exitCode = options;
+      this.code = "FILESYSTEM_ERROR";
+    } else {
+      this.exitCode = options.exitCode ?? 1;
+      this.code = options.code ?? "FILESYSTEM_ERROR";
+      this.hint = options.hint;
+      this.scope = options.scope;
+      this.path = options.path;
+    }
+  }
+};
+
+// src/core/page-area.ts
+var PAGE_AREAS = ["public", "user"];
+function isPageArea(value) {
+  return PAGE_AREAS.includes(value);
+}
+function parseAreaOption(args) {
+  const remaining = args.length > 0 ? [args[0]] : [];
+  let area;
+  for (let index = 1; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument.startsWith("--area=")) {
+      throw new CliError(
+        "The --area option must use a separate public or user value.",
+        {
+          code: "INVALID_ARGUMENT",
+          hint: "Use --area public or --area user."
+        }
+      );
+    }
+    if (argument !== "--area") {
+      remaining.push(argument);
+      continue;
+    }
+    if (area) {
+      throw new CliError("The --area option can only be provided once.", {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+      throw new CliError("The --area option requires public or user.", {
+        code: "INVALID_ARGUMENT",
+        hint: "Use --area public or --area user."
+      });
+    }
+    if (!isPageArea(value)) {
+      throw new CliError(`Unsupported page area: ${value}.`, {
+        code: "INVALID_ARGUMENT",
+        hint: "Use --area public or --area user."
+      });
+    }
+    area = value;
+    index += 1;
+  }
+  return { area, args: remaining };
+}
+function requirePageArea(area, command) {
+  if (area) return area;
+  throw new CliError(`The ${command} command requires --area public or user.`, {
+    code: "INVALID_ARGUMENT",
+    hint: `Run ${command} with --area public or --area user.`
+  });
+}
+function areaRouteGroup(area) {
+  return `(${area})`;
+}
+
 // src/core/page-catalog.ts
 import path from "path";
 function isRouteGroup(segment) {
   return segment.startsWith("(") && segment.endsWith(")");
 }
-async function discoverPages(projectRoot, fs) {
-  const appRoot = path.join(projectRoot, "src", "app", "[locale]");
-  const candidates = [];
+function logicalSegments(relative) {
+  return relative.filter((segment) => !isRouteGroup(segment));
+}
+function issueForRoute(projectRoot, directory, relative) {
+  const segments = logicalSegments(relative);
+  if (segments.length === 0 || segments.some(
+    (segment) => segment.startsWith("_") || segment.startsWith("[")
+  )) {
+    return void 0;
+  }
+  const first = relative[0];
+  if (!first || !isRouteGroup(first)) {
+    return {
+      logicalName: segments.join("."),
+      reason: "ungrouped",
+      routeDirectories: [path.relative(projectRoot, directory)]
+    };
+  }
+  const groupName = first.slice(1, -1);
+  if (!isPageArea(groupName) || relative.slice(1).some(isRouteGroup)) {
+    return {
+      logicalName: segments.join("."),
+      reason: "unsupported-route-group",
+      routeDirectories: [path.relative(projectRoot, directory)]
+    };
+  }
+  return void 0;
+}
+async function discoverPageCatalog(projectRoot, fs) {
+  const localizedRoot = path.join(projectRoot, "src", "app", "[locale]");
+  const appRoot = fs.exists(localizedRoot) ? localizedRoot : path.join(projectRoot, "src", "app");
+  const rawCandidates = [];
+  const issues = [];
   async function visit(directory, relative = []) {
     let entries;
     try {
@@ -22,26 +132,32 @@ async function discoverPages(projectRoot, fs) {
       return;
     }
     if (entries.some((entry) => entry.isFile && entry.name === "page.tsx")) {
-      const routeSegments = relative.filter(
-        (segment) => !isRouteGroup(segment)
-      );
-      if (routeSegments.length > 0 && !routeSegments.some(
-        (segment) => segment.startsWith("_") || segment.startsWith("[")
-      )) {
-        const logicalName = routeSegments.join(".");
-        candidates.push({
-          logicalName,
-          routeSegments,
-          routeDirectory: directory,
-          uiDirectory: path.join(projectRoot, "src", "ui", ...routeSegments),
-          messageFile: path.join(
-            projectRoot,
-            "messages",
-            "{locale}",
-            `${routeSegments[0]}.json`
-          ),
-          messageKey: routeSegments.length > 1 ? routeSegments.at(-1) : void 0
-        });
+      const issue = issueForRoute(projectRoot, directory, relative);
+      if (issue) {
+        issues.push(issue);
+      } else if (relative.length > 1) {
+        const area = relative[0].slice(1, -1);
+        const routeSegments = relative.slice(1);
+        if (routeSegments.length > 0 && !routeSegments.some(
+          (segment) => segment.startsWith("_") || segment.startsWith("[")
+        )) {
+          const logicalName = routeSegments.join(".");
+          rawCandidates.push({
+            id: `${area}:${logicalName}`,
+            area,
+            logicalName,
+            routeSegments,
+            routeDirectory: directory,
+            uiDirectory: path.join(projectRoot, "src", "ui", ...routeSegments),
+            messageFile: path.join(
+              projectRoot,
+              "messages",
+              "{locale}",
+              `${routeSegments[0]}.json`
+            ),
+            messageKey: routeSegments.length > 1 ? routeSegments.at(-1) : void 0
+          });
+        }
       }
     }
     for (const entry of entries) {
@@ -54,9 +170,59 @@ async function discoverPages(projectRoot, fs) {
     }
   }
   await visit(appRoot);
-  return candidates.sort(
+  const candidatesByName = /* @__PURE__ */ new Map();
+  for (const candidate of rawCandidates) {
+    const entries = candidatesByName.get(candidate.logicalName) ?? [];
+    entries.push(candidate);
+    candidatesByName.set(candidate.logicalName, entries);
+  }
+  for (const [logicalName, candidates2] of candidatesByName) {
+    if (candidates2.length < 2) continue;
+    issues.push({
+      logicalName,
+      reason: "duplicate-logical-route",
+      routeDirectories: candidates2.map(
+        (candidate) => path.relative(projectRoot, candidate.routeDirectory)
+      )
+    });
+  }
+  const invalidNames = new Set(issues.map((issue) => issue.logicalName));
+  const candidates = rawCandidates.filter((candidate) => !invalidNames.has(candidate.logicalName)).sort(
+    (left, right) => left.area.localeCompare(right.area) || left.logicalName.localeCompare(right.logicalName)
+  );
+  issues.sort(
     (left, right) => left.logicalName.localeCompare(right.logicalName)
   );
+  return { candidates, issues };
+}
+function routeIssue(catalog, logicalName) {
+  return catalog.issues.find((issue) => issue.logicalName === logicalName);
+}
+function assertConsistentLogicalRoute(catalog, logicalName) {
+  const issue = routeIssue(catalog, logicalName);
+  if (!issue) return;
+  throw new CliError(`Page route "${logicalName}" is inconsistent.`, {
+    code: "INCONSISTENT_ROUTE",
+    scope: "project",
+    path: issue.routeDirectories.join(", "),
+    hint: "Move the route into exactly one of the (public) or (user) areas before retrying."
+  });
+}
+function resolvePageCandidate(catalog, logicalName, area) {
+  assertConsistentLogicalRoute(catalog, logicalName);
+  const candidate = catalog.candidates.find(
+    (entry) => entry.logicalName === logicalName && entry.area === area
+  );
+  if (candidate) return candidate;
+  const otherArea = catalog.candidates.find(
+    (entry) => entry.logicalName === logicalName
+  );
+  throw new CliError(`Page not found in the ${area} area: ${logicalName}.`, {
+    code: "TARGET_NOT_FOUND",
+    scope: "project",
+    path: logicalName.replaceAll(".", "/"),
+    hint: otherArea ? `The page exists in the ${otherArea.area} area.` : void 0
+  });
 }
 
 // src/cli/completion.ts
@@ -75,6 +241,7 @@ var PUBLIC_COMMANDS = [
 ];
 var OPTIONS = {
   addpage: [
+    "--area",
     "--layout",
     "--page",
     "--loading",
@@ -94,22 +261,57 @@ async function directories(root, context) {
     return [];
   }
 }
-async function completionCandidates(command, context) {
-  if (!command) return [...PUBLIC_COMMANDS];
+function selectedArea(args) {
+  const index = args.lastIndexOf("--area");
+  if (index < 0) return void 0;
+  const value = args[index + 1];
+  return value && isPageArea(value) ? value : void 0;
+}
+function uniqueSorted(candidates) {
+  return [...new Set(candidates)].sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function completionCandidates(words, context) {
+  if (words.length === 0) return [...PUBLIC_COMMANDS];
+  const [command, ...args] = words;
+  const previous = args.at(-1);
+  if (previous === "--area") return [...PAGE_AREAS];
+  const area = selectedArea(args);
+  const hasArea = args.includes("--area");
   if (command === "rmpage") {
-    return (await discoverPages(context.cwd, context.fs)).map(
-      (candidate) => candidate.logicalName
+    if (!area) return hasArea ? [] : ["--area"];
+    const catalog = await discoverPageCatalog(context.cwd, context.fs);
+    return uniqueSorted(
+      catalog.candidates.filter((candidate) => candidate.area === area).map((candidate) => candidate.logicalName)
     );
   }
-  if (command === "addcomponent" || command === "addpage") {
-    return [
-      ...OPTIONS[command] ?? [],
+  if (command === "addcomponent") {
+    const pageOptionIndex = args.findIndex(
+      (argument) => argument === "--page" || argument === "-P"
+    );
+    if (previous === "--page" || previous === "-P") {
+      const catalog = await discoverPageCatalog(context.cwd, context.fs);
+      return uniqueSorted(
+        catalog.candidates.filter((candidate) => !area || candidate.area === area).map((candidate) => candidate.logicalName)
+      );
+    }
+    return uniqueSorted([
+      ...OPTIONS.addcomponent ?? [],
+      ...pageOptionIndex >= 0 && !hasArea ? ["--area"] : []
+    ]);
+  }
+  if (command === "addpage") {
+    return uniqueSorted([
+      ...(OPTIONS.addpage ?? []).filter(
+        (candidate) => candidate !== "--area" || !hasArea
+      ),
       ...await directories(path2.join(context.cwd, "src", "ui"), context)
-    ];
+    ]);
   }
   if (command === "addlanguage")
     return ["de", "en", "es", "fr", "it", "ja", "pt"];
-  return OPTIONS[command] ?? [];
+  return uniqueSorted(OPTIONS[command] ?? []);
 }
 
 // src/cli/onboarding.ts
@@ -117,31 +319,6 @@ import path4 from "path";
 
 // src/core/operations.ts
 import path3 from "path";
-
-// src/core/contracts.ts
-var CliError = class extends Error {
-  exitCode;
-  code;
-  hint;
-  scope;
-  path;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "CliError";
-    if (typeof options === "number") {
-      this.exitCode = options;
-      this.code = "FILESYSTEM_ERROR";
-    } else {
-      this.exitCode = options.exitCode ?? 1;
-      this.code = options.code ?? "FILESYSTEM_ERROR";
-      this.hint = options.hint;
-      this.scope = options.scope;
-      this.path = options.path;
-    }
-  }
-};
-
-// src/core/operations.ts
 var OperationJournal = class {
   #events = [];
   record(event) {
@@ -755,18 +932,64 @@ var addApi = async (args, context) => {
 
 // src/lib/addComponent.ts
 import { join as join3 } from "path";
-var addComponent = async (args, context) => {
-  let componentName = args[1];
-  const pageIndex = args.findIndex(
-    (argument) => argument === "-P" || argument === "--page"
+function formatGeneratedTranslations(content) {
+  return content.replace(
+    /^(\s*)(<(?:h2|p)\b[^>]*>)\{t\("([^"]+)"\)\}(<\/(?:h2|p)>)$/gm,
+    (line, indent, opening, key, closing) => line.length <= 80 ? line : `${indent}${opening}
+${indent}  {t("${key}")}
+${indent}${closing}`
   );
-  const pageScope = pageIndex >= 0 ? args[pageIndex + 1] : void 0;
-  if (pageIndex >= 0 && !pageScope) {
-    throw new CliError("The --page option requires a page name.", {
-      code: "INVALID_ARGUMENT"
-    });
+}
+function parseAddComponentArguments(args) {
+  const parsedArea = parseAreaOption(args);
+  let componentName;
+  let pageScope;
+  for (let index = 1; index < parsedArea.args.length; index += 1) {
+    const argument = parsedArea.args[index];
+    if (argument === "-P" || argument === "--page") {
+      if (pageScope) {
+        throw new CliError("The --page option can only be provided once.", {
+          code: "INVALID_ARGUMENT"
+        });
+      }
+      const value = parsedArea.args[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new CliError("The --page option requires a page name.", {
+          code: "INVALID_ARGUMENT"
+        });
+      }
+      pageScope = value;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("-")) {
+      throw new CliError(`Unknown addcomponent option: ${argument}.`, {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    if (componentName) {
+      throw new CliError(`Unexpected addcomponent argument: ${argument}.`, {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    componentName = argument;
+  }
+  if (pageScope && !parsedArea.area) {
+    requirePageArea(parsedArea.area, "addcomponent --page");
   }
-  if (!componentName || componentName.startsWith("-")) {
+  if (!pageScope && parsedArea.area) {
+    throw new CliError(
+      "The --area option is only valid with addcomponent --page.",
+      { code: "INVALID_ARGUMENT" }
+    );
+  }
+  return { area: parsedArea.area, componentName, pageScope };
+}
+var addComponent = async (args, context) => {
+  const parsed = parseAddComponentArguments(args);
+  let { componentName } = parsed;
+  const { area, pageScope } = parsed;
+  if (!componentName) {
     if (context.outputMode === "json") {
       throw new CliError("Component name is required in JSON mode.", {
         code: "INTERACTIVE_INPUT_REQUIRED",
@@ -810,6 +1033,10 @@ var addComponent = async (args, context) => {
       hint: "Run this command from the generated project root."
     });
   }
+  if (pageScope) {
+    const catalog = await discoverPageCatalog(context.cwd, context.fs);
+    resolvePageCandidate(catalog, pageScope, area);
+  }
   const componentNameUpper = capitalize(toIdentifier(componentName));
   const templateRoot = join3(context.packageRoot, "templates", "Component");
   const componentTemplate = join3(templateRoot, "Component.tsx");
@@ -825,7 +1052,9 @@ var addComponent = async (args, context) => {
   await assertSafeTarget(context.cwd, targetDirectory, context.fs);
   const componentFile = join3(targetDirectory, `${componentNameUpper}.tsx`);
   const translationNamespace = pageScope ?? "_global_ui";
-  const componentContent = (await context.fs.readText(componentTemplate)).replace(/Component/g, componentNameUpper).replace(/componentPage/g, translationNamespace);
+  const componentContent = formatGeneratedTranslations(
+    (await context.fs.readText(componentTemplate)).replace(/Component/g, componentNameUpper).replace(/componentPage/g, translationNamespace)
+  );
   const preparedMessages = [];
   if (config.useI18n) {
     const messagesRoot = join3(context.cwd, "messages");
@@ -836,6 +1065,7 @@ var addComponent = async (args, context) => {
         path: "messages"
       });
     }
+    await assertSafeTarget(context.cwd, messagesRoot, context.fs);
     const templateMessages = JSON.parse(
       await context.fs.readText(messagesTemplate)
     );
@@ -850,6 +1080,7 @@ var addComponent = async (args, context) => {
     for (const locale of locales) {
       const messageFile = pageScope ? pageSegments[0] : "_global_ui";
       const target = join3(messagesRoot, locale, `${messageFile}.json`);
+      await assertSafeTarget(context.cwd, target, context.fs);
       let data = {};
       if (context.fs.exists(target)) {
         try {
@@ -896,17 +1127,20 @@ var addComponent = async (args, context) => {
   const gateway = new MutationGateway(context, context.cwd);
   await gateway.mkdir(targetDirectory, {
     role: "component-directory",
-    resource: "directory"
+    resource: "directory",
+    detail: area ? { area } : void 0
   });
   await gateway.write(componentFile, componentContent, {
     role: "ui-component",
-    preserveExisting: true
+    preserveExisting: true,
+    detail: area ? { area } : void 0
   });
   for (const item of preparedMessages) {
     if (item.exists) {
       gateway.unchanged(item.target, {
         role: "translation-messages",
         detail: {
+          ...area ? { area } : {},
           locale: item.locale,
           key: `${translationNamespace}.${componentNameUpper}`
         }
@@ -915,6 +1149,7 @@ var addComponent = async (args, context) => {
       await gateway.write(item.target, item.content, {
         role: "translation-messages",
         detail: {
+          ...area ? { area } : {},
           locale: item.locale,
           key: `${translationNamespace}.${componentNameUpper}`
         }
@@ -924,8 +1159,9 @@ var addComponent = async (args, context) => {
   const mutated = context.operations.snapshot().some((event) => event.action === "created" || event.action === "updated");
   return commandResult(context, {
     command: "addcomponent",
-    summary: mutated ? `Added component "${componentNameUpper}" ${pageScope ? `to page "${pageScope}"` : "globally"}.` : `Component "${componentNameUpper}" already exists and was preserved.`,
+    summary: mutated ? `Added component "${componentNameUpper}" ${pageScope ? `to ${area} page "${pageScope}"` : "globally"}.` : pageScope ? `Component "${componentNameUpper}" already exists on ${area} page "${pageScope}" and was preserved.` : `Component "${componentNameUpper}" already exists and was preserved.`,
     projectRoot: context.cwd,
+    data: pageScope ? { area, componentName: componentNameUpper, page: pageScope } : { componentName: componentNameUpper },
     nextSteps: mutated ? [
       {
         kind: "review",
@@ -1394,7 +1630,6 @@ var SHORT_FLAGS = {
 };
 function registerMessagesFile(content, locale, fileName) {
   const importPath = `./${locale}/${fileName}.json`;
-  if (content.includes(importPath)) return content;
   const declarationIndex = content.indexOf("const messages =");
   const registryMatch = content.match(/const messages = \{([\s\S]*?)\n\};/);
   if (declarationIndex < 0 || !registryMatch) {
@@ -1408,19 +1643,30 @@ function registerMessagesFile(content, locale, fileName) {
     );
   }
   const identifier = toIdentifier(fileName);
+  const property = identifier === fileName ? `  ${identifier},` : `  ${JSON.stringify(fileName)}: ${identifier},`;
+  if (content.includes(importPath)) {
+    if (registryMatch[1].split(/\r?\n/).includes(property)) return content;
+    const legacyProperty = new RegExp(`^\\s*${identifier},\\s*$`, "m");
+    if (legacyProperty.test(registryMatch[1])) {
+      return content.replace(legacyProperty, property);
+    }
+    const nextRegistry2 = registryMatch[0].replace(
+      /\n\};$/,
+      `
+${property}
+};`
+    );
+    return content.replace(registryMatch[0], nextRegistry2);
+  }
   const importStatement = `import ${identifier} from "${importPath}";
 `;
-  const nextRegistry = registryMatch[0].replace(
-    /\n\};$/,
-    `
-  ${identifier},
-};`
-  );
+  const nextRegistry = registryMatch[0].replace(/\n\};$/, `
+${property}
+};`);
   return content.slice(0, declarationIndex) + importStatement + content.slice(declarationIndex).replace(registryMatch[0], nextRegistry);
 }
-function selectedFlags(args) {
+function selectedFlags(optionArguments) {
   const selected = /* @__PURE__ */ new Set();
-  const optionArguments = args.slice(2).filter((argument) => argument.startsWith("-"));
   if (optionArguments.length === 0)
     return /* @__PURE__ */ new Set(["layout", "page", "loading"]);
   for (const argument of optionArguments) {
@@ -1446,23 +1692,61 @@ function selectedFlags(args) {
   }
   return selected;
 }
+function parseAddPageArguments(args) {
+  const parsedArea = parseAreaOption(args);
+  let logicalName;
+  const optionArguments = [];
+  for (const argument of parsedArea.args.slice(1)) {
+    if (argument.startsWith("-")) {
+      optionArguments.push(argument);
+      continue;
+    }
+    if (logicalName) {
+      throw new CliError(`Unexpected addpage argument: ${argument}.`, {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    logicalName = argument;
+  }
+  return {
+    area: parsedArea.area,
+    logicalName,
+    flags: selectedFlags(optionArguments)
+  };
+}
 var addPage = async (args, context) => {
-  let logicalName = args[1];
-  if (!logicalName || logicalName.startsWith("-")) {
+  const parsed = parseAddPageArguments(args);
+  let { area, logicalName } = parsed;
+  if (!logicalName) {
     if (context.outputMode === "json") {
       throw new CliError("Page name is required in JSON mode.", {
         code: "INTERACTIVE_INPUT_REQUIRED",
         hint: "Pass a simple or Parent.Child page name after addpage."
       });
     }
-    const response = await context.prompt({
-      type: "text",
-      name: "pageName",
-      message: "Page name to add:",
-      validate: (name) => name ? true : "Page name is required"
-    });
+    const questions = [
+      {
+        type: "text",
+        name: "pageName",
+        message: "Page name to add:",
+        validate: (name) => name ? true : "Page name is required"
+      },
+      ...!area ? [
+        {
+          type: "select",
+          name: "area",
+          message: "Page area:",
+          choices: [
+            { title: "public", value: "public" },
+            { title: "user", value: "user" }
+          ]
+        }
+      ] : []
+    ];
+    const response = await context.prompt(questions);
     logicalName = String(response.pageName ?? "");
-    if (!logicalName) {
+    area = area ?? response.area;
+    if (!logicalName || !area) {
       context.operations.record({
         action: "cancelled",
         resource: "command",
@@ -1477,14 +1761,17 @@ var addPage = async (args, context) => {
         status: "cancelled"
       });
     }
+  } else {
+    area = requirePageArea(area, "addpage");
   }
+  area = requirePageArea(area, "addpage");
   const pageSegments = parseLogicalName(logicalName, "page name");
   if (pageSegments.length > 2) {
     throw new CliError("Nested pages support exactly Parent.Child.", {
       code: "INVALID_ARGUMENT"
     });
   }
-  const flags = selectedFlags(args);
+  const flags = parsed.flags;
   const config = await loadConfig(context);
   if (!config) {
     throw new CliError("Configuration file cnp.config.json was not found.", {
@@ -1507,16 +1794,64 @@ var addPage = async (args, context) => {
       path: useI18n ? "src/app/[locale]" : "src/app"
     });
   }
+  const areaRoot = join6(appRoot, areaRouteGroup(area));
+  if (!context.fs.exists(areaRoot)) {
+    throw new CliError(`The ${area} page area was not found.`, {
+      code: "CONFIG_NOT_FOUND",
+      scope: "project",
+      path: join6(
+        useI18n ? "src/app/[locale]" : "src/app",
+        areaRouteGroup(area)
+      )
+    });
+  }
   const [parentName, childName] = pageSegments.length === 2 ? pageSegments : [void 0, void 0];
   const leafName = childName ?? pageSegments[0];
   const pageIdentifier = capitalize(toIdentifier(leafName));
   const jsonFileName = parentName ?? leafName;
   const uiDirectory = join6(context.cwd, "src", "ui", ...pageSegments);
-  const routeDirectory = join6(appRoot, ...pageSegments);
+  const routeDirectory = join6(areaRoot, ...pageSegments);
+  const catalog = await discoverPageCatalog(context.cwd, context.fs);
+  assertConsistentLogicalRoute(catalog, logicalName);
+  const existingOtherArea = catalog.candidates.find(
+    (candidate) => candidate.logicalName === logicalName && candidate.area !== area
+  );
+  const otherArea = area === "public" ? "user" : "public";
+  const otherAreaDirectory = join6(
+    appRoot,
+    areaRouteGroup(otherArea),
+    ...pageSegments
+  );
+  if (existingOtherArea || context.fs.exists(otherAreaDirectory)) {
+    throw new CliError(
+      `Page "${logicalName}" already belongs to the ${otherArea} area.`,
+      {
+        code: "TARGET_EXISTS",
+        scope: "project",
+        path: join6(
+          useI18n ? "src/app/[locale]" : "src/app",
+          areaRouteGroup(otherArea),
+          ...pageSegments
+        )
+      }
+    );
+  }
+  const legacyDirectory = join6(appRoot, ...pageSegments);
+  if (context.fs.exists(legacyDirectory)) {
+    throw new CliError(`Page route "${logicalName}" is ungrouped.`, {
+      code: "INCONSISTENT_ROUTE",
+      scope: "project",
+      path: join6(useI18n ? "src/app/[locale]" : "src/app", ...pageSegments),
+      hint: "Move the route into exactly one of the (public) or (user) areas before retrying."
+    });
+  }
   await assertSafeTarget(context.cwd, uiDirectory, context.fs);
   await assertSafeTarget(context.cwd, routeDirectory, context.fs);
   const templateRoot = join6(context.packageRoot, "templates", "Page");
-  const uiTemplate = join6(templateRoot, "page-ui.tsx");
+  const uiTemplate = join6(
+    templateRoot,
+    area === "user" ? "page-ui.user.tsx" : "page-ui.tsx"
+  );
   const routeTemplates = [...flags].map((flag) => ({
     flag,
     source: join6(templateRoot, toFileName(flag))
@@ -1551,6 +1886,7 @@ var addPage = async (args, context) => {
         path: "messages"
       });
     }
+    await assertSafeTarget(context.cwd, messagesRoot, context.fs);
     const locales = (await context.fs.list(messagesRoot)).filter((entry) => entry.isDirectory).map((entry) => entry.name).sort();
     if (locales.length === 0) {
       throw new CliError("No locale directories were found.", {
@@ -1562,6 +1898,8 @@ var addPage = async (args, context) => {
     for (const locale of locales) {
       const target = join6(messagesRoot, locale, `${jsonFileName}.json`);
       const aggregator = join6(messagesRoot, `${locale}.ts`);
+      await assertSafeTarget(context.cwd, target, context.fs);
+      await assertSafeTarget(context.cwd, aggregator, context.fs);
       if (!context.fs.exists(aggregator)) {
         throw new CliError(
           `Locale aggregator messages/${locale}.ts was not found.`,
@@ -1612,7 +1950,8 @@ var addPage = async (args, context) => {
   const gateway = new MutationGateway(context, context.cwd);
   await gateway.mkdir(uiDirectory, {
     role: "page-ui-directory",
-    resource: "directory"
+    resource: "directory",
+    detail: { area }
   });
   const uiFile = join6(uiDirectory, "page-ui.tsx");
   const uiContent = (await context.fs.readText(uiTemplate)).replace(
@@ -1621,11 +1960,13 @@ var addPage = async (args, context) => {
   ).replaceAll('from "@/', `from "${aliasPrefix}/`).replace(/template/g, pageIdentifier).replace(/Template/g, pageIdentifier);
   await gateway.write(uiFile, uiContent, {
     role: "page-ui",
-    preserveExisting: true
+    preserveExisting: true,
+    detail: { area }
   });
   await gateway.mkdir(routeDirectory, {
     role: "page-route-directory",
-    resource: "directory"
+    resource: "directory",
+    detail: { area }
   });
   for (const template of routeTemplates) {
     const filename = toFileName(template.flag);
@@ -1634,7 +1975,8 @@ var addPage = async (args, context) => {
     const content = (await context.fs.readText(template.source)).replace("@/ui/template/", `@/ui/${uiImportPath}/`).replaceAll('from "@/', `from "${aliasPrefix}/`).replace(/template/g, pageIdentifier).replace(/Template/g, pageIdentifier);
     await gateway.write(target, content, {
       role: `page-${template.flag}`,
-      preserveExisting: true
+      preserveExisting: true,
+      detail: { area }
     });
   }
   if (useI18n) {
@@ -1642,23 +1984,32 @@ var addPage = async (args, context) => {
       if (item.messageExists) {
         gateway.unchanged(item.target, {
           role: "translation-messages",
-          detail: { locale: item.locale, namespace: translationNamespace }
+          detail: {
+            area,
+            locale: item.locale,
+            namespace: translationNamespace
+          }
         });
       } else {
         await gateway.write(item.target, item.targetContent, {
           role: "translation-messages",
-          detail: { locale: item.locale, namespace: translationNamespace }
+          detail: {
+            area,
+            locale: item.locale,
+            namespace: translationNamespace
+          }
         });
       }
       await gateway.write(item.aggregator, item.aggregatorContent, {
-        role: "locale-aggregator"
+        role: "locale-aggregator",
+        detail: { area }
       });
     }
   } else {
     gateway.skipped(join6(context.cwd, "messages"), {
       role: "translation-messages",
       resource: "directory",
-      detail: { reason: "Internationalization is disabled." }
+      detail: { area, reason: "Internationalization is disabled." }
     });
   }
   const mutated = context.operations.snapshot().some(
@@ -1677,8 +2028,9 @@ var addPage = async (args, context) => {
   ];
   return commandResult(context, {
     command: "addpage",
-    summary: mutated ? `Added page "${logicalName}" and its missing resources.` : `Page "${logicalName}" already exists and was preserved.`,
+    summary: mutated ? `Added ${area} page "${logicalName}" and its missing resources.` : `${area[0].toUpperCase()}${area.slice(1)} page "${logicalName}" already exists and was preserved.`,
     projectRoot: context.cwd,
+    data: { area, logicalName },
     nextSteps: mutated ? [
       {
         kind: "review",
@@ -1841,13 +2193,15 @@ function escapeRegExp(value) {
 function unregisterMessagesFile(content, locale, fileName) {
   const identifier = toIdentifier(fileName);
   const escapedIdentifier = escapeRegExp(identifier);
+  const escapedFileName = escapeRegExp(fileName);
   const escapedPath = escapeRegExp(`./${locale}/${fileName}.json`);
   const importPattern = new RegExp(
     `^import\\s+${escapedIdentifier}\\s+from\\s+["']${escapedPath}["'];?\\r?\\n?`,
     "m"
   );
+  const propertyExpression = identifier === fileName ? escapedIdentifier : `(?:["']${escapedFileName}["']\\s*:\\s*)?${escapedIdentifier}`;
   const propertyPattern = new RegExp(
-    `^\\s*${escapedIdentifier},\\s*\\r?\\n?`,
+    `^\\s*${propertyExpression},\\s*\\r?\\n?`,
     "m"
   );
   const hasImport = importPattern.test(content);
@@ -1868,24 +2222,63 @@ function unregisterMessagesFile(content, locale, fileName) {
     changed: true
   };
 }
+function parseRmPageArguments(args) {
+  const parsedArea = parseAreaOption(args);
+  let logicalName;
+  for (const argument of parsedArea.args.slice(1)) {
+    if (argument.startsWith("-")) {
+      throw new CliError(`Unknown rmpage option: ${argument}.`, {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    if (logicalName) {
+      throw new CliError(`Unexpected rmpage argument: ${argument}.`, {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    logicalName = argument;
+  }
+  return { area: parsedArea.area, logicalName };
+}
 var rmPage = async (args, context) => {
-  const candidates = await discoverPages(context.cwd, context.fs);
-  let logicalName = args[1];
-  if (!logicalName || logicalName.startsWith("-")) {
+  const parsed = parseRmPageArguments(args);
+  const catalog = await discoverPageCatalog(context.cwd, context.fs);
+  let { area, logicalName } = parsed;
+  let candidate;
+  if (!logicalName) {
     if (context.outputMode === "json") {
       throw new CliError("Page name is required in JSON mode.", {
         code: "INTERACTIVE_INPUT_REQUIRED",
         hint: "Pass a page name returned by completion after rmpage."
       });
     }
+    const candidates = area ? catalog.candidates.filter((entry) => entry.area === area) : catalog.candidates;
+    if (candidates.length === 0) {
+      const issue = catalog.issues[0];
+      if (issue) {
+        throw new CliError(
+          `Page route "${issue.logicalName}" is inconsistent.`,
+          {
+            code: "INCONSISTENT_ROUTE",
+            scope: "project",
+            path: issue.routeDirectories.join(", "),
+            hint: "Move the route into exactly one of the (public) or (user) areas before retrying."
+          }
+        );
+      }
+      throw new CliError(
+        area ? `No pages were found in the ${area} area.` : "No removable pages were found.",
+        { code: "TARGET_NOT_FOUND", scope: "project", path: "." }
+      );
+    }
     const selected = await context.prompt([
       {
         type: "autocomplete",
         name: "page",
         message: "Page to remove:",
         choices: candidates.map((candidate2) => ({
-          title: candidate2.logicalName.replaceAll(".", " > "),
-          value: candidate2.logicalName
+          title: `${candidate2.area[0].toUpperCase()}${candidate2.area.slice(1)} > ${candidate2.logicalName.replaceAll(".", " > ")}`,
+          value: candidate2.id
         }))
       },
       {
@@ -1895,38 +2288,51 @@ var rmPage = async (args, context) => {
         initial: false
       }
     ]);
+    const selectedId = String(selected.page ?? "");
+    const selectedCandidate = candidates.find(
+      (entry) => entry.id === selectedId
+    );
     if (!selected.confirm) {
       context.operations.record({
         action: "cancelled",
         resource: "command",
         role: "page-removal",
         scope: "project",
-        path: "."
+        path: ".",
+        detail: selectedCandidate ? { area: selectedCandidate.area } : area ? { area } : void 0
       });
       return commandResult(context, {
         command: "rmpage",
-        summary: "Page deletion was cancelled.",
+        summary: selectedCandidate ? `Deletion of ${selectedCandidate.area} page "${selectedCandidate.logicalName}" was cancelled.` : area ? `Page deletion in the ${area} area was cancelled.` : "Page deletion was cancelled.",
         projectRoot: context.cwd,
-        status: "cancelled"
+        status: "cancelled",
+        data: selectedCandidate ? {
+          area: selectedCandidate.area,
+          logicalName: selectedCandidate.logicalName
+        } : area ? { area } : void 0
       });
     }
-    logicalName = String(selected.page ?? "");
-  }
-  parseLogicalName(logicalName, "page name");
-  const candidate = candidates.find(
-    (entry) => entry.logicalName === logicalName
-  );
-  if (!candidate) {
-    throw new CliError(`Page not found: ${logicalName}.`, {
-      code: "TARGET_NOT_FOUND",
-      scope: "project",
-      path: logicalName.replaceAll(".", "/")
-    });
+    if (!selectedCandidate) {
+      throw new CliError("The selected page is not in the page catalog.", {
+        code: "INVALID_ARGUMENT"
+      });
+    }
+    candidate = selectedCandidate;
+    logicalName = candidate.logicalName;
+    area = candidate.area;
+  } else {
+    area = requirePageArea(area, "rmpage");
+    parseLogicalName(logicalName, "page name");
+    candidate = resolvePageCandidate(catalog, logicalName, area);
   }
+  area = requirePageArea(area, "rmpage");
   const messagesRoot = resolveInside(context.cwd, "messages");
+  await assertSafeTarget(context.cwd, candidate.uiDirectory, context.fs);
+  await assertSafeTarget(context.cwd, candidate.routeDirectory, context.fs);
   const preparedMessages = [];
   const preparedAggregators = [];
   if (context.fs.exists(messagesRoot)) {
+    await assertSafeTarget(context.cwd, messagesRoot, context.fs);
     const locales = (await context.fs.list(messagesRoot)).filter((entry) => entry.isDirectory).map((entry) => entry.name).sort();
     for (const locale of locales) {
       const target = resolveInside(
@@ -1935,12 +2341,14 @@ var rmPage = async (args, context) => {
         locale,
         `${candidate.routeSegments[0]}.json`
       );
+      await assertSafeTarget(context.cwd, target, context.fs);
       if (!candidate.messageKey) {
         const aggregator = resolveInside(
           context.cwd,
           "messages",
           `${locale}.ts`
         );
+        await assertSafeTarget(context.cwd, aggregator, context.fs);
         if (!context.fs.exists(aggregator)) {
           throw new CliError(
             `Locale aggregator messages/${locale}.ts was not found.`,
@@ -1993,33 +2401,41 @@ var rmPage = async (args, context) => {
   const gateway = new MutationGateway(context, context.cwd);
   for (const prepared of preparedMessages) {
     if (!candidate.messageKey) {
-      await gateway.remove(prepared.target, { role: "translation-messages" });
+      await gateway.remove(prepared.target, {
+        role: "translation-messages",
+        detail: { area }
+      });
     } else if (prepared.keyPresent) {
       await gateway.write(prepared.target, prepared.content, {
         role: "translation-messages",
-        detail: { removedKey: candidate.messageKey }
+        detail: { area, removedKey: candidate.messageKey }
       });
     } else {
       gateway.unchanged(prepared.target, {
         role: "translation-messages",
-        detail: { missingKey: candidate.messageKey }
+        detail: { area, missingKey: candidate.messageKey }
       });
     }
   }
   for (const prepared of preparedAggregators) {
     if (prepared.changed) {
       await gateway.write(prepared.target, prepared.content, {
-        role: "locale-aggregator"
+        role: "locale-aggregator",
+        detail: { area }
       });
     } else {
-      gateway.unchanged(prepared.target, { role: "locale-aggregator" });
+      gateway.unchanged(prepared.target, {
+        role: "locale-aggregator",
+        detail: { area }
+      });
     }
   }
   await gateway.remove(
     candidate.uiDirectory,
     {
       role: "page-ui",
-      resource: "directory"
+      resource: "directory",
+      detail: { area }
     },
     { recursive: true, force: false }
   );
@@ -2027,15 +2443,17 @@ var rmPage = async (args, context) => {
     candidate.routeDirectory,
     {
       role: "page-route",
-      resource: "directory"
+      resource: "directory",
+      detail: { area }
     },
     { recursive: true, force: false }
   );
   const mutated = context.operations.snapshot().some((event) => event.action === "deleted" || event.action === "updated");
   return commandResult(context, {
     command: "rmpage",
-    summary: mutated ? `Deleted page "${logicalName}" and its associated resources.` : `No resources remained for page "${logicalName}".`,
+    summary: mutated ? `Deleted ${area} page "${logicalName}" and its associated resources.` : `No resources remained for ${area} page "${logicalName}".`,
     projectRoot: context.cwd,
+    data: { area, logicalName },
     nextSteps: mutated ? [
       {
         kind: "run-checks",
@@ -2145,6 +2563,7 @@ async function validateScaffoldTemplate(root, fs) {
     "bun.lock",
     "pnpm-workspace.yaml",
     "vitest.config.ts",
+    path8.join("scripts", "audit-policy.ts"),
     path8.join("scripts", "audit.ts"),
     path8.join("scripts", "package-manager.ts"),
     path8.join("tests", "consumer", "validate-template.ts"),
@@ -2581,18 +3000,19 @@ var HELP_TEXT = `create-next-pro
 
 Usage:
   create-next-pro <project-name> [--force] [--json]
-  create-next-pro addpage [options] [--json]
-  create-next-pro addcomponent [options] [--json]
+  create-next-pro addpage [name] --area <public|user> [options] [--json]
+  create-next-pro addcomponent [name] [--page <page> --area <public|user>] [--json]
   create-next-pro addlib [name] [--json]
   create-next-pro addapi [name] [--json]
   create-next-pro addlanguage [locale] [--json]
   create-next-pro addtext <path> [text] [--json]
-  create-next-pro rmpage [options] [--json]
+  create-next-pro rmpage [name] [--area <public|user>] [--json]
 
 Options:
   --help          Show this help message
   --version       Show the CLI version
   --json          Emit one deterministic JSON document
+  --area          Select the public or user area for page operations
   --reconfigure   Run the configuration assistant again
 `;
 function parseOptions(args) {
@@ -2680,7 +3100,10 @@ async function executeCli(context) {
 }
 async function runCompletion(context, args) {
   try {
-    for (const candidate of await completionCandidates(args[1], context)) {
+    for (const candidate of await completionCandidates(
+      args.slice(1),
+      context
+    )) {
       context.terminal.log(candidate);
     }
     return 0;