pasika 0.10.94 → 0.10.96

package/dist/eslint/pasika/index.js

@@ -444,8 +444,8 @@ function parseModule(file) {
       }
       continue;
     }
-    const isExported2 = ts.canHaveModifiers(statement) ? (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) : false;
-    if (!isExported2) continue;
+    const isExported3 = ts.canHaveModifiers(statement) ? (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) : false;
+    if (!isExported3) continue;
     if (ts.isFunctionDeclaration(statement) && statement.name) {
       const name = statement.name.text;
       exports.push({
@@ -3261,19 +3261,34 @@ var enumPlacementRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require TypeScript enum declarations to live in constants/ folders."
+      description: "Keep file-local enums local, place shared enums in constants/, and avoid one-member enums."
     }
   },
   create(context) {
     const filename = path25.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
     if (!filename.startsWith(sourceRoot + path25.sep)) return {};
-    if (path25.basename(path25.dirname(filename)) === "constants") return {};
+    const inConstantsFolder = path25.basename(path25.dirname(filename)) === "constants";
+    const index = getProjectIndex(sourceRoot);
     return {
       TSEnumDeclaration(node) {
+        const enumBody = "body" in node ? node.body : void 0;
+        const members = enumBody && typeof enumBody === "object" && "members" in enumBody ? enumBody.members : void 0;
+        const enumId = "id" in node ? node.id : void 0;
+        const enumName = enumId && typeof enumId === "object" && "name" in enumId ? enumId.name : void 0;
+        if (!Array.isArray(members) || typeof enumName !== "string") return;
+        if (members.length === 1) {
+          context.report({
+            node,
+            message: "A single named string or number value must be a const, not a one-member enum. See docs/next-codebase-guide/rules/constants-rule.md"
+          });
+          return;
+        }
+        const shared = (index?.symbolConsumers.get(symbolKey(filename, enumName))?.size ?? 0) > 0;
+        if (inConstantsFolder || !shared) return;
         context.report({
           node,
-          message: "A TypeScript enum must live in a constants/ folder because it creates runtime values as well as a type. See docs/next-codebase-guide/rules/constants-rule.md"
+          message: "An enum imported by another file must live in a constants/ folder at its CCF; keep file-local enums beside their consumers. See docs/next-codebase-guide/rules/constants-rule.md"
         });
       }
     };
@@ -3970,7 +3985,7 @@ var importBoundariesRule = {
       const isAppLocalStyleImport = importerLayer === "app" && importedLayer === "app" && styleExtensions.has(extension);
       const importedIsRootSupport = rootSupportFolders.has(importedLayer);
       const importedIsSameConfig = importerLayer === "config" && importedLayer === "config" && importer[1] === imported[1];
-      const isAllowed = !isCodeModule && importerLayer === "app" && isAppLocalStyleImport || isCodeModule && importerLayer === "app" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "compositions" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "features" && (importedLayer === "features" && importerFeature === importedFeature || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "shared" && (importedLayer === "shared" || importedIsRootSupport) || isCodeModule && rootSupportFolders.has(importerLayer) && importedIsRootSupport && (importerLayer !== "config" || importedLayer !== "config" || importedIsSameConfig);
+      const isAllowed = !isCodeModule && importerLayer === "app" && isAppLocalStyleImport || isCodeModule && importerLayer === "app" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "compositions" && (importedLayer === "compositions" || importedLayer === "features" || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "features" && (importedLayer === "features" && importerFeature === importedFeature || importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importerLayer === "shared" && (importedLayer === "shared" || importedIsRootSupport) || isCodeModule && importer.length === 1 && importedIsRootSupport || isCodeModule && rootSupportFolders.has(importerLayer) && importedIsRootSupport && (importerLayer !== "config" || importedLayer !== "config" || importedIsSameConfig);
       if (!isAllowed) {
         context.report({
           node: source,
@@ -4069,12 +4084,13 @@ var importThroughIndexRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require imports of support files to use their support-folder index."
+      description: "Enforce public support barrels and direct sibling constants imports."
     }
   },
   create(context) {
     const filename = path32.resolve(context.filename);
     const sourceRoot = sourceRootOf2(context, filename);
+    const importerSegments = segmentsOf(filename, sourceRoot);
     return {
       Program(node) {
         for (const specifier of importSpecifiers(context.sourceCode.text)) {
@@ -4085,8 +4101,19 @@ var importThroughIndexRule = {
             (segment) => ["constants", "types", "schemas"].includes(segment)
           );
           const supportFolder = supportFolderIndex >= 0 ? targetSegments[supportFolderIndex] : void 0;
-          if (!supportFolder || path32.basename(target).startsWith("index.")) continue;
+          if (!supportFolder) continue;
           const folderIndex = targetSegments.slice(0, supportFolderIndex + 1);
+          const withinSameSupportFolder = importerSegments.length > supportFolderIndex + 1 && folderIndex.every((segment, index) => importerSegments[index] === segment);
+          if (path32.basename(target).startsWith("index.")) {
+            if (supportFolder === "constants" && withinSameSupportFolder) {
+              context.report({
+                node,
+                message: `Import sibling constants directly instead of through "${specifier}" to avoid circular barrel imports. See the next-codebase-guide constants rule.`
+              });
+            }
+            continue;
+          }
+          if (withinSameSupportFolder) continue;
           const expected = `@/${folderIndex.join("/")}`;
           context.report({
             node,
@@ -4602,10 +4629,10 @@ function localePlacement(text) {
   const sourceFile = ts6.createSourceFile("locales.ts", text, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
   for (const statement of sourceFile.statements) {
     if (!ts6.isVariableStatement(statement)) continue;
-    const isExported2 = (ts6.getModifiers(statement) ?? []).some(
+    const isExported3 = (ts6.getModifiers(statement) ?? []).some(
       (modifier) => modifier.kind === ts6.SyntaxKind.ExportKeyword
     );
-    if (!isExported2) continue;
+    if (!isExported3) continue;
     for (const declaration of statement.declarationList.declarations) {
       if (!ts6.isIdentifier(declaration.name) || declaration.name.text !== "locales") continue;
       if (!declaration.initializer || !ts6.isObjectLiteralExpression(declaration.initializer)) continue;
@@ -6349,7 +6376,7 @@ var preferEnumRule = {
         }
         for (const unionCall of discriminatedUnions) {
           const [discriminatorArg, optionsArg] = unionCall.arguments ?? [];
-          if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression") {
+          if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression" || optionsArg.elements.length < 2) {
             continue;
           }
           for (const option of optionsArg.elements) {
@@ -6379,7 +6406,7 @@ var preferEnumRule = {
         }
         const expression = node.expression;
         if (!expression || expression.type !== "ObjectExpression") return;
-        if (expression.properties.length === 0) return;
+        if (expression.properties.length < 2) return;
         if (!expression.properties.every(isEnumConvertibleProperty)) return;
         context.report({
           node,
@@ -7097,7 +7124,7 @@ var repeatedNumericValueRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require repeated named numeric values across production files to use one extracted constant or enum."
+      description: "Require repeated named numeric values across production files to use one shared constant."
     }
   },
   create(context) {
@@ -7132,7 +7159,467 @@ var repeatedNumericValueRule = {
           context.report({
             node,
             loc: { line: literal.line, column: 0 },
-            message: `The numeric value ${String(literal.value)} is repeated for the "${literal.semanticName}" semantic slot in ${String(files.size)} production files. Extract one constant or enum at their CCF and import it instead. See docs/next-codebase-guide/rules/constants-rule.md`
+            message: `The numeric value ${String(literal.value)} is repeated for the "${literal.semanticName}" semantic slot in ${String(files.size)} production files. Extract one constant at their CCF and import it instead. See docs/next-codebase-guide/rules/constants-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint/rules/repeated-semantic-literal.ts
+import path49 from "path";
+
+// eslint/project/semantic-literals.ts
+import { readFileSync as readFileSync10 } from "fs";
+import path47 from "path";
+import ts10 from "typescript";
+var excludedProperties = /* @__PURE__ */ new Set([
+  "label",
+  "title",
+  "description",
+  "message",
+  "text",
+  "placeholder",
+  "className",
+  "content",
+  "alt",
+  "src",
+  "href",
+  "url",
+  "html",
+  "ariaLabel",
+  "testId"
+]);
+var semanticProperties = /* @__PURE__ */ new Set(["status", "phase", "event", "eventName", "action", "storageKey", "endpoint"]);
+var semanticVariableName = /route|path|key|status|event|timeout|delay|token|column|endpoint|limit|duration/i;
+var columnMethods = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "is",
+  "in",
+  "order",
+  "filter",
+  "not"
+]);
+var eventMethods = /* @__PURE__ */ new Set(["emit", "on", "off", "once", "addListener", "removeListener"]);
+var ignoredNumbers = /* @__PURE__ */ new Set([-1, 0, 1]);
+function isProductionSource(file, root) {
+  const parts = path47.relative(root, file).split(path47.sep);
+  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path47.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
+}
+function featureOf(file, root) {
+  const parts = path47.relative(root, file).split(path47.sep);
+  if (parts[0] === "features" && parts[1]) return `feature:${parts[1]}`;
+  return `layer:${parts[0] ?? "src"}`;
+}
+function nameOf(property) {
+  if (ts10.isIdentifier(property) || ts10.isStringLiteral(property)) return property.text;
+  return void 0;
+}
+function literalOf(node) {
+  if (ts10.isStringLiteral(node)) return node.text;
+  if (ts10.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
+  if (ts10.isPrefixUnaryExpression(node) && node.operator === ts10.SyntaxKind.MinusToken && ts10.isNumericLiteral(node.operand)) {
+    return -Number(node.operand.text.replaceAll("_", ""));
+  }
+  return void 0;
+}
+function isLiteralRoot(node) {
+  if (ts10.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
+  return (ts10.isStringLiteral(node) || ts10.isNumericLiteral(node)) && !(ts10.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
+}
+function invocation(node) {
+  if (ts10.isIdentifier(node.expression)) return { method: node.expression.text };
+  if (ts10.isPropertyAccessExpression(node.expression)) {
+    const receiver = node.expression.expression.getText();
+    if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/.test(receiver)) return void 0;
+    return { method: node.expression.name.text, receiver };
+  }
+  return void 0;
+}
+function isPathname(node) {
+  return ts10.isPropertyAccessExpression(node) && node.name.text === "pathname";
+}
+function contextFor(node, value, file, root) {
+  if (typeof value === "number" && ignoredNumbers.has(value)) return void 0;
+  if (typeof value === "string" && (value.length < 3 || /\s/.test(value))) return void 0;
+  const parent = node.parent;
+  const scope = featureOf(file, root);
+  const isApiRoute = typeof value === "string" && value.startsWith("/api/") && !/[?&#\s]/.test(value);
+  const route = () => ({ role: "api-route", family: "api-route" });
+  if (ts10.isPropertyAssignment(parent) && parent.initializer === node) {
+    const name = nameOf(parent.name);
+    if (!name) return void 0;
+    if (name === "path" && isApiRoute) return route();
+    if (!semanticProperties.has(name)) return void 0;
+    if (typeof value === "number") return void 0;
+    if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
+    return { role: `property:${name}:${scope}`, family: `property:${name}` };
+  }
+  if (ts10.isVariableDeclaration(parent) && parent.initializer === node && ts10.isIdentifier(parent.name)) {
+    if (typeof value === "number") return void 0;
+    const name = parent.name.text;
+    if (excludedProperties.has(name) || !semanticVariableName.test(name)) return void 0;
+    if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
+    return { role: `variable:${name}:${scope}`, family: `variable:${name}` };
+  }
+  if (ts10.isCallExpression(parent)) {
+    const position = parent.arguments.findIndex((argument) => argument === node);
+    if (position < 0) return void 0;
+    const call = invocation(parent);
+    if (!call) return void 0;
+    if (isApiRoute && position === 0 && (call.method === "fetch" || call.method === "zodFetch")) return route();
+    if (typeof value === "number" && position === 1 && (call.method === "setTimeout" || call.method === "setInterval")) {
+      return { role: `timer:${call.method}:${scope}`, family: "timer" };
+    }
+    if (typeof value === "string" && position === 0 && call.receiver && (call.receiver === "localStorage" || call.receiver === "sessionStorage") && ["getItem", "setItem", "removeItem"].includes(call.method)) {
+      return { role: `storage:${call.receiver}`, family: "storage" };
+    }
+    if (typeof value === "string" && position === 0 && call.receiver && eventMethods.has(call.method) && /(?:event|bus|socket|emitter)/i.test(call.receiver)) {
+      return { role: `event:${call.receiver}`, family: "event" };
+    }
+    if (typeof value === "string" && position === 0 && call.receiver && columnMethods.has(call.method) && value.length > 3 && /^[a-z][a-z0-9_]*$/.test(value)) {
+      return { role: `column:${scope}`, family: "column" };
+    }
+  }
+  if (isApiRoute && ts10.isBinaryExpression(parent) && (parent.operatorToken.kind === ts10.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts10.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
+    return route();
+  }
+  if (isApiRoute && ts10.isCallExpression(parent) && parent.arguments[0] === node && ts10.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
+    return route();
+  }
+  return void 0;
+}
+function isExported2(node) {
+  return ts10.canHaveModifiers(node) && (ts10.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword);
+}
+function parse(file, root, output) {
+  if (!isProductionSource(file, root)) return;
+  const source = ts10.createSourceFile(
+    file,
+    readFileSync10(file, "utf8"),
+    ts10.ScriptTarget.Latest,
+    true,
+    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts10.ScriptKind.TSX : ts10.ScriptKind.TS
+  );
+  const inConstants = path47.relative(root, file).split(path47.sep).includes("constants");
+  for (const statement of source.statements) {
+    if (inConstants && ts10.isEnumDeclaration(statement) && isExported2(statement)) {
+      for (const member of statement.members) {
+        const value = member.initializer && literalOf(member.initializer);
+        const memberName9 = nameOf(member.name);
+        if (value === void 0 || !memberName9) continue;
+        output.canonicals.push({
+          file,
+          name: memberName9,
+          owner: statement.name.text,
+          kind: typeof value === "string" ? "string" : "number",
+          value
+        });
+      }
+    }
+    if (inConstants && ts10.isVariableStatement(statement) && isExported2(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts10.isIdentifier(declaration.name) || !declaration.initializer) continue;
+        const value = literalOf(declaration.initializer);
+        if (value === void 0) continue;
+        output.canonicals.push({
+          file,
+          name: declaration.name.text,
+          kind: typeof value === "string" ? "string" : "number",
+          value
+        });
+      }
+    }
+  }
+  const visit = (node) => {
+    if (isLiteralRoot(node)) {
+      const value = literalOf(node);
+      if (value !== void 0) {
+        const semantic = contextFor(node, value, file, root);
+        if (semantic) {
+          const declaration = node.parent;
+          const isCanonicalDefinition = inConstants && (ts10.isVariableDeclaration(declaration) && ts10.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts10.isEnumMember(declaration));
+          if ((!inConstants || semantic.family === "api-route") && !isCanonicalDefinition) {
+            const position = source.getLineAndCharacterOfPosition(node.getStart(source));
+            output.uses.push({
+              file,
+              kind: typeof value === "string" ? "string" : "number",
+              value,
+              line: position.line + 1,
+              column: position.character,
+              ...semantic
+            });
+          }
+        }
+      }
+    }
+    ts10.forEachChild(node, visit);
+  };
+  visit(source);
+}
+var cache3 = /* @__PURE__ */ new WeakMap();
+function getSemanticLiteralIndex(index) {
+  const previous = cache3.get(index);
+  if (previous) return previous;
+  const result = { uses: [], canonicals: [] };
+  for (const file of index.modules.keys()) {
+    try {
+      parse(file, index.sourceRoot, result);
+    } catch {
+    }
+  }
+  cache3.set(index, result);
+  return result;
+}
+
+// eslint/rules/imported-enum-literals.ts
+import path48 from "path";
+import ts11 from "typescript";
+var columnMethods2 = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "is",
+  "in",
+  "order",
+  "filter",
+  "not"
+]);
+function memberName6(name) {
+  if (ts11.isIdentifier(name) || ts11.isStringLiteral(name)) return name.text;
+  return void 0;
+}
+function isWithin3(root, file) {
+  const relative = path48.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path48.isAbsolute(relative);
+}
+function domainOf(name) {
+  if (name.endsWith("ColumnEnum")) return "column";
+  if (name.endsWith("Route") || name.endsWith("RouteEnum")) return "route";
+  return void 0;
+}
+function importedEnums(file, checker, sourceRoot, importedNames) {
+  const matches = /* @__PURE__ */ new Map();
+  for (const statement of file.statements) {
+    if (!ts11.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts11.isNamedImports(statement.importClause.namedBindings)) {
+      continue;
+    }
+    for (const specifier of statement.importClause.namedBindings.elements) {
+      if (!importedNames.has(specifier.name.text)) continue;
+      const symbol = checker.getSymbolAtLocation(specifier.name);
+      if (!symbol) continue;
+      const resolved = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      for (const declaration of resolved.declarations ?? []) {
+        if (!ts11.isEnumDeclaration(declaration)) continue;
+        const declarationFile = path48.resolve(declaration.getSourceFile().fileName);
+        if (!isWithin3(sourceRoot, declarationFile)) continue;
+        const domain = domainOf(declaration.name.text);
+        if (!domain) continue;
+        for (const member of declaration.members) {
+          if (!member.initializer || !ts11.isStringLiteral(member.initializer)) continue;
+          const name = memberName6(member.name);
+          if (!name) continue;
+          const entries = matches.get(member.initializer.text) ?? [];
+          entries.push({
+            reference: `${specifier.name.text}.${name}`,
+            domain,
+            sourceFile: declarationFile
+          });
+          matches.set(member.initializer.text, entries);
+        }
+      }
+    }
+  }
+  return matches;
+}
+function isPathname2(node) {
+  return ts11.isPropertyAccessExpression(node) && node.name.text === "pathname";
+}
+function domainForUse(node) {
+  const parent = node.parent;
+  if (ts11.isPropertyAssignment(parent) && parent.initializer === node && memberName6(parent.name) === "path") {
+    return "route";
+  }
+  if (ts11.isCallExpression(parent) && parent.arguments[0] === node && ts11.isPropertyAccessExpression(parent.expression)) {
+    const { expression, name } = parent.expression;
+    if (columnMethods2.has(name.text)) return "column";
+    if (name.text === "startsWith" && isPathname2(expression)) return "route";
+  }
+  if (ts11.isBinaryExpression(parent) && (parent.operatorToken.kind === ts11.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts11.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname2(parent.right) || parent.right === node && isPathname2(parent.left))) {
+    return "route";
+  }
+  return void 0;
+}
+function importedEnumLiteralUses(context, root) {
+  const filename = path48.resolve(context.filename);
+  if (!isWithin3(root, filename)) return [];
+  const services = typedParserServices(context.sourceCode.parserServices);
+  if (!services) return [];
+  const file = services.program.getSourceFile(filename);
+  if (file?.text !== context.sourceCode.text) return [];
+  const importedNames = /* @__PURE__ */ new Set();
+  for (const statement of context.sourceCode.ast.body) {
+    if (statement.type !== "ImportDeclaration") continue;
+    for (const specifier of statement.specifiers) importedNames.add(specifier.local.name);
+  }
+  if (importedNames.size === 0) return [];
+  const matches = importedEnums(file, services.program.getTypeChecker(), root, importedNames);
+  if (matches.size === 0) return [];
+  const uses = [];
+  const visit = (node) => {
+    if (ts11.isStringLiteral(node)) {
+      const domain = domainForUse(node);
+      const candidates = matches.get(node.text)?.filter((entry) => entry.domain === domain) ?? [];
+      if (candidates.length === 1) {
+        const match = candidates[0];
+        if (match) {
+          const position = file.getLineAndCharacterOfPosition(node.getStart(file));
+          uses.push({
+            reference: match.reference,
+            sourceFile: match.sourceFile,
+            value: node.text,
+            line: position.line + 1,
+            column: position.character
+          });
+        }
+      }
+    }
+    ts11.forEachChild(node, visit);
+  };
+  visit(file);
+  return uses;
+}
+
+// eslint/rules/repeated-semantic-literal.ts
+var DOC6 = "See docs/next-codebase-guide/rules/constants-rule.md";
+function canonicalMatches(use, canonical, sourceRoot) {
+  if (use.kind !== canonical.kind || use.value !== canonical.value) return false;
+  const name = canonical.owner ?? canonical.name;
+  if (use.family === "api-route") return /route|path|endpoint/i.test(name);
+  if (use.family === "column") return /column/i.test(name);
+  if (use.family === "timer") return /timeout|delay|interval/i.test(name);
+  if (use.family === "storage") return /key|storage/i.test(name);
+  if (use.family === "event") return /event/i.test(name);
+  if (use.family.startsWith("property:") || use.family.startsWith("variable:")) {
+    const semanticName2 = use.family.split(":")[1];
+    if (!semanticName2 || !name.toLowerCase().includes(semanticName2.toLowerCase())) return false;
+    const location = featureOf(canonical.file, sourceRoot);
+    return location === featureOf(use.file, sourceRoot) || path49.relative(sourceRoot, canonical.file).split(path49.sep)[0] === "constants";
+  }
+  return false;
+}
+function formatValue(use) {
+  return typeof use.value === "string" ? JSON.stringify(use.value) : String(use.value);
+}
+function canonicalName(canonical) {
+  return canonical.owner ? `${canonical.owner}.${canonical.name}` : canonical.name;
+}
+function messageFor(use, matches, duplicateRouteDomains, existingRouteEnum, root) {
+  const count = new Set(matches.map((match) => match.file)).size;
+  const kind = use.kind === "string" ? "string" : "numeric";
+  if (use.family === "api-route" && existingRouteEnum?.owner) {
+    const location = path49.relative(root, existingRouteEnum.file).replaceAll(path49.sep, "/");
+    return `The route ${formatValue(use)} repeats; add a member to existing ${existingRouteEnum.owner} in src/${location} and reuse it. ${DOC6}`;
+  }
+  if (count === 1) {
+    return `The ${kind} literal ${formatValue(use)} repeats in the same semantic role in this file. Extract a file-local const. ${DOC6}`;
+  }
+  const placement = use.family === "api-route" && duplicateRouteDomains.has(use.role) ? "a shared enum for this closed route domain" : "one shared const";
+  return `The ${kind} literal ${formatValue(use)} repeats in ${String(count)} production files for the same semantic role. Extract ${placement} at the consumers' CCF and import it. ${DOC6}`;
+}
+var repeatedSemanticLiteralRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Reuse canonical string/number values or extract semantically repeated literals at their CCF."
+    }
+  },
+  create(context) {
+    const root = sourceRootOf(context);
+    const file = path49.resolve(context.filename);
+    if (!isProductionSource(file, root)) return {};
+    const project = getProjectIndex(root);
+    if (!project?.modules.has(file)) return {};
+    const index = getSemanticLiteralIndex(project);
+    const current = index.uses.filter((entry) => entry.file === file);
+    const imported = importedEnumLiteralUses(context, root);
+    if (current.length === 0 && imported.length === 0) return {};
+    const groups = /* @__PURE__ */ new Map();
+    for (const use of index.uses) {
+      const key = `${use.kind}\0${String(use.value)}\0${use.role}`;
+      const group = groups.get(key) ?? [];
+      group.push(use);
+      groups.set(key, group);
+    }
+    const duplicatedApiRoutes = /* @__PURE__ */ new Set();
+    const routeValues = /* @__PURE__ */ new Map();
+    for (const group of groups.values()) {
+      const first = group[0];
+      if (group.length < 2 || first?.family !== "api-route") continue;
+      const values = routeValues.get(first.role) ?? /* @__PURE__ */ new Set();
+      values.add(String(first.value));
+      routeValues.set(first.role, values);
+    }
+    for (const [role, values] of routeValues) {
+      if (values.size >= 2) duplicatedApiRoutes.add(role);
+    }
+    const routeDomains = /* @__PURE__ */ new Map();
+    for (const canonical of index.canonicals) {
+      if (canonical.owner && /^ApiRoute(?:Enum)?$/.test(canonical.owner)) {
+        routeDomains.set(`${canonical.file}:${canonical.owner}`, canonical);
+      }
+    }
+    const existingRouteEnum = routeDomains.size === 1 ? [...routeDomains.values()][0] : void 0;
+    const recognized = new Set(imported.map((use) => `${String(use.line)}:${String(use.column)}`));
+    return {
+      Program(node) {
+        for (const use of imported) {
+          const relative = path49.relative(root, use.sourceFile).replaceAll(path49.sep, "/");
+          context.report({
+            node,
+            loc: { line: use.line, column: use.column },
+            message: `Reuse ${use.reference} from src/${relative} instead of raw ${JSON.stringify(use.value)}. ${DOC6}`
+          });
+        }
+        for (const use of current) {
+          if (recognized.has(`${String(use.line)}:${String(use.column)}`)) continue;
+          const candidates = index.canonicals.filter(
+            (canonical) => canonicalMatches(use, canonical, root) && canonical.file !== file
+          );
+          if (candidates.length === 1) {
+            const canonical = candidates[0];
+            if (!canonical) continue;
+            const relative = path49.relative(root, canonical.file).replaceAll(path49.sep, "/");
+            context.report({
+              node,
+              loc: { line: use.line, column: use.column },
+              message: `Reuse ${canonicalName(canonical)} from src/${relative} instead of raw ${formatValue(use)}. ${DOC6}`
+            });
+            continue;
+          }
+          if (candidates.length > 1) continue;
+          const key = `${use.kind}\0${String(use.value)}\0${use.role}`;
+          const peers = groups.get(key) ?? [];
+          if (peers.length < 2) continue;
+          if (use.kind === "number" && !use.family.startsWith("timer")) continue;
+          context.report({
+            node,
+            loc: { line: use.line, column: use.column },
+            message: messageFor(use, peers, duplicatedApiRoutes, existingRouteEnum, root)
           });
         }
       }
@@ -7322,7 +7809,7 @@ var repeatedStructureRule = {
 
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path47 from "path";
+import path50 from "path";
 var SUPPORT_FOLDERS3 = /* @__PURE__ */ new Set(["constants", "types", "schemas"]);
 var INDEX_NAMES = /* @__PURE__ */ new Set(["index.ts", "index.tsx", "index.mts", "index.cts"]);
 var MODULE_EXTENSIONS3 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
@@ -7330,9 +7817,9 @@ function resolveSiblingModule(indexFile, specifier) {
   if (!specifier.startsWith("./")) return void 0;
   const relative = specifier.slice(2);
   if (!relative || relative.includes("/")) return void 0;
-  const directory = path47.dirname(indexFile);
-  const direct = path47.resolve(directory, relative);
-  const candidates = path47.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path50.dirname(indexFile);
+  const direct = path50.resolve(directory, relative);
+  const candidates = path50.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -7345,9 +7832,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path47.resolve(context.filename);
-    if (!INDEX_NAMES.has(path47.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path47.basename(path47.dirname(filename)))) return {};
+    const filename = path50.resolve(context.filename);
+    if (!INDEX_NAMES.has(path50.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path50.basename(path50.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -7400,7 +7887,7 @@ var requireBarrelStarExportsRule = {
 };
 
 // eslint/rules/root-support-placement.ts
-import path48 from "path";
+import path51 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -7433,7 +7920,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path48.resolve(context.filename);
+    const file = path51.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -7479,8 +7966,8 @@ var rootSupportPlacementRule = {
 };
 
 // eslint/rules/route-handler-shape.ts
-import path49 from "path";
-import ts10 from "typescript";
+import path52 from "path";
+import ts12 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -7498,33 +7985,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts10.isForStatement(node) || ts10.isForOfStatement(node) || ts10.isForInStatement(node) || ts10.isWhileStatement(node) || ts10.isDoStatement(node);
+  return ts12.isForStatement(node) || ts12.isForOfStatement(node) || ts12.isForInStatement(node) || ts12.isWhileStatement(node) || ts12.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isFunctionDeclaration(node);
+  return ts12.isFunctionExpression(node) || ts12.isArrowFunction(node) || ts12.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts10.createSourceFile(
+  const sourceFile = ts12.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts10.ScriptTarget.Latest,
+    ts12.ScriptTarget.Latest,
     true,
-    ts10.ScriptKind.TS
+    ts12.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts10.isTryStatement(node)) kinds.add("try");
+    if (ts12.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts10.isIfStatement(node)) kinds.add("if");
-    if (ts10.isCallExpression(node) && ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts12.isIfStatement(node)) kinds.add("if");
+    if (ts12.isCallExpression(node) && ts12.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts12.isCallExpression(node) && ts12.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts10.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -7564,7 +8051,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path49.basename(context.filename) !== "route.ts") return {};
+    if (path52.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -7623,7 +8110,7 @@ var routeHandlerShapeRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path50 from "path";
+import path53 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -7651,9 +8138,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path50.resolve(context.filename);
+    const filename = path53.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path50.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path53.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -7685,39 +8172,39 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path51 from "path";
-import ts11 from "typescript";
+import path54 from "path";
+import ts13 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts11.isCallExpression(child) && ts11.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts11.isVariableDeclaration(child.parent)) {
+    if (ts13.isCallExpression(child) && ts13.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts13.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts11.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts13.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts11.isBindingElement(value) && ts11.isBindingElement(updater)) {
+          if (value && updater && ts13.isBindingElement(value) && ts13.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts11.isIdentifier(valueName) && ts11.isIdentifier(updaterName)) {
+            if (ts13.isIdentifier(valueName) && ts13.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts11.forEachChild(child, visit);
+    ts13.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts13.isCallExpression(node) && ts13.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts11.isIdentifier(node) && node.text === hook.value) {
+  if (ts13.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts11.isBindingElement(parent) || ts11.isPropertyAccessExpression(parent) || ts11.isShorthandPropertyAssignment(parent)) {
+    if (ts13.isBindingElement(parent) || ts13.isPropertyAccessExpression(parent) || ts13.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -7727,16 +8214,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts11.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts11.isJsxFragment(expression)) {
+  while (ts13.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts13.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
+      (c) => !ts13.isJsxText(c) && !ts13.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts11.isJsxElement(expression)) {
+  if (ts13.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
+      (c) => !ts13.isJsxText(c) && !ts13.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -7750,8 +8237,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node)) return;
-    ts11.forEachChild(node, visit);
+    if (ts13.isFunctionDeclaration(node) || ts13.isClassDeclaration(node)) return;
+    ts13.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -7765,7 +8252,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path51.resolve(context.filename);
+    const filename = path54.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -7790,18 +8277,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts11.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts11.isBlock(body)) return void 0;
+  const body = ts13.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts13.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts11.isFunctionLike(node) || ts11.isClassLike(node))) return;
-    if (ts11.isReturnStatement(node)) returns.push(node);
-    ts11.forEachChild(node, visit);
+    if (node !== body && (ts13.isFunctionLike(node) || ts13.isClassLike(node))) return;
+    if (ts13.isReturnStatement(node)) returns.push(node);
+    ts13.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts11.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts13.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -7824,11 +8311,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts13.isFunctionDeclaration(node) || ts13.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts11.isSourceFile(current)) {
+      while (!ts13.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -7837,14 +8324,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts11.forEachChild(node, visit);
+    ts13.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 
 // eslint/rules/source-under-src.ts
-import path52 from "path";
+import path55 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -7885,14 +8372,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path52.resolve(context.filename);
+    const filename = path55.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path52.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path55.relative(context.cwd, filename).replace(/\\/g, "/");
     if (relative === "src" || relative.startsWith("src/")) return {};
     const topLevel = relative.split("/")[0] ?? "";
     if (NON_SOURCE_ROOT_DIRS.has(topLevel)) return {};
     if (!relative.includes("/")) {
-      const basename = path52.basename(filename);
+      const basename = path55.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -7908,7 +8395,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path53 from "path";
+import path56 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -7919,7 +8406,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path53.resolve(context.filename);
+    const file = path56.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -7959,7 +8446,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path54 from "path";
+import path57 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -7984,7 +8471,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path54.resolve(context.filename);
+    const supportFile = path57.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -8038,7 +8525,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path55 from "path";
+import path58 from "path";
 var SUPPORT_FOLDERS4 = /* @__PURE__ */ new Set(["constants", "types", "schemas"]);
 var INDEX_NAMES2 = /* @__PURE__ */ new Set(["index.ts", "index.tsx", "index.mts", "index.cts"]);
 var supportFolderShapeRule = {
@@ -8050,12 +8537,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path55.resolve(context.filename);
-    const baseName = path55.basename(filename);
+    const filename = path58.resolve(context.filename);
+    const baseName = path58.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path55.basename(path55.dirname(filename));
+    const folder = path58.basename(path58.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path55.dirname(filename);
+    const directory = path58.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -8073,7 +8560,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path55.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path58.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -8252,11 +8739,11 @@ var baseLayerPairRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path58 from "path";
+import path61 from "path";
 
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
-import path56 from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
+import path59 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
@@ -8269,7 +8756,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path56.join(dir, entry);
+    const entryPath = path59.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -8277,7 +8764,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path56.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path59.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -8286,7 +8773,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync10(file, "utf8");
+        text = readFileSync11(file, "utf8");
       } catch {
         text = "";
       }
@@ -8300,7 +8787,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path57 from "path";
+import path60 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -8314,25 +8801,25 @@ function moduleImports(text, fileName) {
   return new RegExp(`(?:import|require)\\s*\\(?\\s*["'][^"']*${escaped}["']`, "i").test(text);
 }
 function resolveSpecifier2(fromFile, spec, sourceRoot) {
-  if (spec.startsWith("/")) return path57.resolve(spec);
-  if (spec.startsWith("./") || spec.startsWith("../")) return path57.resolve(path57.dirname(fromFile), spec);
-  if (spec.startsWith("@/")) return path57.resolve(sourceRoot, spec.slice(2));
+  if (spec.startsWith("/")) return path60.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path60.resolve(path60.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path60.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path57.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path60.normalize(file)));
   const globals = cssFiles.filter((file) => registersTailwind(textOf(file)));
   const reachable = /* @__PURE__ */ new Set();
   const queue = [...globals];
-  for (const global of globals) reachable.add(path57.normalize(global));
+  for (const global of globals) reachable.add(path60.normalize(global));
   while (queue.length > 0) {
     const from = queue.shift();
     if (!from) continue;
     for (const spec of importedSpecifiers(textOf(from))) {
       const target = resolveSpecifier2(from, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path57.normalize(target);
+      const normalized = path60.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -8344,7 +8831,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path57.normalize(target);
+      const normalized = path60.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -8352,8 +8839,8 @@ function buildStylesheetGraph(options) {
 }
 
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path58.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path58.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path61.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path61.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -8379,8 +8866,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path58.normalize(path58.resolve(context.filename));
-        const relative = path58.relative(sourceRoot, current);
+        const current = path61.normalize(path61.resolve(context.filename));
+        const relative = path61.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -8396,7 +8883,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path58.basename(current);
+          const basename = path61.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -8406,7 +8893,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path58.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path61.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -8895,7 +9382,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path59 from "path";
+import path62 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -8906,7 +9393,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path59.resolve(context.filename);
+    const file = path62.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -9045,9 +9532,9 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync6 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path60 from "path";
+import path63 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -9287,7 +9774,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path60.join(dir, entry);
+    const entryPath = path63.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -9295,7 +9782,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path60.extname(entry) === ".css" ? [entryPath] : [];
+    return path63.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -9306,24 +9793,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path60.dirname(fromFile);
-  while (directory !== path60.dirname(directory)) {
-    const packageRoot = path60.join(directory, "node_modules", packageName);
-    const manifestPath = path60.join(packageRoot, "package.json");
+  let directory = path63.dirname(fromFile);
+  while (directory !== path63.dirname(directory)) {
+    const packageRoot = path63.join(directory, "node_modules", packageName);
+    const manifestPath = path63.join(packageRoot, "package.json");
     if (existsSync6(manifestPath)) {
       try {
-        const manifest = readFileSync11(manifestPath, "utf8");
+        const manifest = readFileSync12(manifestPath, "utf8");
         const stylesheet = /"style"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path60.resolve(packageRoot, target);
+        const resolved = path63.resolve(packageRoot, target);
         return existsSync6(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path60.dirname(directory);
+    directory = path63.dirname(directory);
   }
   return void 0;
 }
@@ -9332,7 +9819,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync11(file, "utf8");
+      css2 = readFileSync12(file, "utf8");
     } catch {
       continue;
     }
@@ -9398,7 +9885,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync11(file, "utf8");
+      css2 = readFileSync12(file, "utf8");
     } catch {
       continue;
     }
@@ -9574,7 +10061,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path61 from "path";
+import path64 from "path";
 function toKebabCase2(value) {
   return value.replace(/(?<lower>[a-z0-9])(?<upper>[A-Z])/g, "$<lower>-$<upper>").replace(/(?<first>[A-Z])(?<rest>[A-Z][a-z])/g, "$<first>-$<rest>").toLowerCase();
 }
@@ -9587,7 +10074,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path61.resolve(context.filename);
+    const filename = path64.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -9601,13 +10088,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path61.basename(filename, path61.extname(filename));
+    const actual = path64.basename(filename, path64.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path61.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path64.extname(filename).slice(1)}.`
         });
       }
     };
@@ -9615,7 +10102,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path62 from "path";
+import path65 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -9626,7 +10113,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path62.resolve(context.filename);
+    const file = path65.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -9647,8 +10134,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
-import path63 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import path66 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -9659,13 +10146,13 @@ var NEXTJS_REQUIRED_TRACKED_DOCS = [
   { name: "next-codebase-guide", path: "docs/next-codebase-guide" },
   { name: "next-tailwind-guide", path: "docs/next-tailwind-guide" }
 ];
-function memberName6(member) {
+function memberName7(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function hasDependency(root, name) {
-  const section = root.members.find((member) => memberName6(member) === "dependencies");
+  const section = root.members.find((member) => memberName7(member) === "dependencies");
   if (section?.value.type !== "Object") return false;
-  return section.value.members.some((member) => memberName6(member) === name);
+  return section.value.members.some((member) => memberName7(member) === name);
 }
 var trackedDocsRule = {
   meta: {
@@ -9681,8 +10168,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path63.dirname(path63.resolve(context.filename));
-        const configPath = path63.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path66.dirname(path66.resolve(context.filename));
+        const configPath = path66.join(projectRoot, "vulyk.config.ts");
         if (!existsSync7(configPath)) {
           context.report({
             node,
@@ -9690,7 +10177,7 @@ var trackedDocsRule = {
           });
           return;
         }
-        const config = readFileSync12(configPath, "utf8");
+        const config = readFileSync13(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -9707,7 +10194,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path63.join(projectRoot, "AGENTS.md");
+        const agentsPath = path66.join(projectRoot, "AGENTS.md");
         if (!existsSync7(agentsPath)) {
           context.report({
             node,
@@ -9720,14 +10207,14 @@ var trackedDocsRule = {
 };
 
 // eslint/rules/vulyk/vulyk-dependency.ts
-function memberName7(member) {
+function memberName8(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function dependency(root, sectionName) {
   if (root.type !== "Object") return void 0;
-  const section = root.members.find((member) => memberName7(member) === sectionName);
+  const section = root.members.find((member) => memberName8(member) === sectionName);
   if (section?.value.type !== "Object") return void 0;
-  return section.value.members.find((member) => memberName7(member) === "vulyk");
+  return section.value.members.find((member) => memberName8(member) === "vulyk");
 }
 var vulykDependencyRule = {
   meta: {
@@ -9768,9 +10255,9 @@ var vulykRules = {
 // eslint/rules/with-response-helper.ts
 var HELPER3 = "withResponse";
 var ENTRY3 = "pasika/with-response";
-var DOC6 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
-var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC6}`;
-var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC6}`;
+var DOC7 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
+var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC7}`;
+var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC7}`;
 function isNamed3(node, name) {
   return node?.type === "Identifier" && node.name === name;
 }
@@ -9807,7 +10294,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path64 from "path";
+import path67 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -9826,10 +10313,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path64.resolve(context.filename);
-    const basename = path64.basename(filename);
+    const filename = path67.resolve(context.filename);
+    const basename = path67.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path64.dirname(filename);
+    const projectRoot = path67.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -9844,7 +10331,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path64.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path67.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -9862,13 +10349,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path64.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path67.join(projectRoot, name)));
         if (!prettierConfigFile) {
           report3(
             "No prettier config found. Create one that takes its configuration from zirka (styleguide({ prettier: true }).prettierConfig)."
           );
         } else {
-          const content = fs7.readFileSync(path64.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path67.join(projectRoot, prettierConfigFile), "utf8");
           if (!content.includes("zirka")) {
             report3(
               "The prettier config must take its configuration from zirka (styleguide({ prettier: true }).prettierConfig) instead of restating it locally."
@@ -9891,10 +10378,10 @@ function referencesZirka(sourceCode) {
 // eslint/rules/zod-fetch-helper.ts
 var HELPER4 = "zodFetch";
 var ENTRY4 = "pasika/zod-fetch";
-var DOC7 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
-var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC7}`;
-var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC7}`;
-var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC7}`;
+var DOC8 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
+var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC8}`;
+var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC8}`;
+var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC8}`;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 var TEST_FILE2 = /(?:^|[\\/])(?:__tests__|tests)[\\/]|[.](?:test|spec)[.][cm]?[jt]sx?$/;
 function isNamed4(node, name) {
@@ -10014,14 +10501,14 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/ts-alignment.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { join } from "path";
 var ownRequire = createRequire2(import.meta.url);
 var majorOf = (version) => Number(version.split(".")[0]);
 function versionOf(packagePath) {
   try {
-    const parsed = JSON.parse(readFileSync13(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync14(packagePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) return null;
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -10081,6 +10568,7 @@ var pasikaNextjsAppRules = {
   "value-extraction": valueExtractionRule,
   "constant-casing": constantCasingRule,
   "prefer-enum": preferEnumRule,
+  "repeated-semantic-literal": repeatedSemanticLiteralRule,
   "prefer-object-destructuring": preferObjectDestructuringRule,
   "enum-placement": enumPlacementRule,
   "type-extraction": typeExtractionRule,