pasika 0.10.96 → 0.10.98

package/dist/eslint/pasika/index.js

@@ -3302,7 +3302,7 @@ var fileLengthRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require application source files to stay at or below 300 lines."
+      description: "Require TypeScript files and application JavaScript files to stay at or below 300 lines."
     }
   },
   create(context) {
@@ -5100,6 +5100,308 @@ var noArbitraryTailwindRule = {
   }
 };
 
+// eslint/rules/no-inline-runtime-literal.ts
+import path40 from "path";
+
+// eslint/project/semantic-literals.ts
+import { readFileSync as readFileSync8 } from "fs";
+import path39 from "path";
+import ts7 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 = path39.relative(root, file).split(path39.sep);
+  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path39.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
+}
+function featureOf(file, root) {
+  const parts = path39.relative(root, file).split(path39.sep);
+  if (parts[0] === "features" && parts[1]) return `feature:${parts[1]}`;
+  return `layer:${parts[0] ?? "src"}`;
+}
+function nameOf(property) {
+  if (ts7.isIdentifier(property) || ts7.isStringLiteral(property)) return property.text;
+  return void 0;
+}
+function literalOf(node) {
+  if (ts7.isStringLiteral(node)) return node.text;
+  if (ts7.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
+  if (ts7.isPrefixUnaryExpression(node) && node.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(node.operand)) {
+    return -Number(node.operand.text.replaceAll("_", ""));
+  }
+  return void 0;
+}
+function isLiteralRoot(node) {
+  if (ts7.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
+  return (ts7.isStringLiteral(node) || ts7.isNumericLiteral(node)) && !(ts7.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
+}
+function invocation(node) {
+  if (ts7.isIdentifier(node.expression)) return { method: node.expression.text };
+  if (ts7.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 ts7.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 (ts7.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 (ts7.isVariableDeclaration(parent) && parent.initializer === node && ts7.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 (ts7.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 && ts7.isBinaryExpression(parent) && (parent.operatorToken.kind === ts7.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts7.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
+    return route();
+  }
+  if (isApiRoute && ts7.isCallExpression(parent) && parent.arguments[0] === node && ts7.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
+    return route();
+  }
+  return void 0;
+}
+function isExported2(node) {
+  return ts7.canHaveModifiers(node) && (ts7.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts7.SyntaxKind.ExportKeyword);
+}
+function parse(file, root, output) {
+  if (!isProductionSource(file, root)) return;
+  const source = ts7.createSourceFile(
+    file,
+    readFileSync8(file, "utf8"),
+    ts7.ScriptTarget.Latest,
+    true,
+    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS
+  );
+  const inConstants = path39.relative(root, file).split(path39.sep).includes("constants");
+  for (const statement of source.statements) {
+    if (inConstants && ts7.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 && ts7.isVariableStatement(statement) && isExported2(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts7.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 && (ts7.isVariableDeclaration(declaration) && ts7.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts7.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
+            });
+          }
+        }
+      }
+    }
+    ts7.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/no-inline-runtime-literal.ts
+var DOC4 = "See docs/next-codebase-guide/rules/constants-rule.md";
+var MESSAGE2 = `Every runtime string or numeric value must use a named constant or enum member, including single-use values. Only JSX className props permit inline values. ${DOC4}`;
+function isClassNameProp(node) {
+  let current = node;
+  while (current.parent) {
+    current = current.parent;
+    if (current.type === "JSXAttribute") {
+      const { name } = current;
+      return typeof name === "object" && name !== null && "name" in name && name.name === "className";
+    }
+    if (current.type === "Program") return false;
+  }
+  return false;
+}
+function containsInlineString(node) {
+  if (typeof node !== "object" || node === null || !("type" in node)) return false;
+  if (node.type === "TemplateLiteral") return true;
+  if (node.type === "Literal") return "value" in node && typeof node.value === "string";
+  if (node.type === "BinaryExpression") {
+    return "left" in node && containsInlineString(node.left) || "right" in node && containsInlineString(node.right);
+  }
+  if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+    return "expression" in node && containsInlineString(node.expression);
+  }
+  return false;
+}
+function isNamedValue(node) {
+  let current = node;
+  while (current.parent) {
+    const parent2 = current.parent;
+    const isTypeWrapper = parent2.type === "TSAsExpression" || parent2.type === "TSSatisfiesExpression";
+    const isSignedNumber = parent2.type === "UnaryExpression" && parent2.argument === current && (parent2.operator === "-" || parent2.operator === "+");
+    const isArithmetic = parent2.type === "BinaryExpression" && typeof parent2.operator === "string" && ["+", "-", "*", "/", "%", "**", "<<", ">>", ">>>", "&", "|", "^"].includes(parent2.operator) && !containsInlineString(parent2.left) && !containsInlineString(parent2.right);
+    if (!isTypeWrapper && !isSignedNumber && !isArithmetic) break;
+    current = parent2;
+  }
+  const parent = current.parent;
+  if (!parent) return false;
+  if (parent.type === "TSEnumMember" && parent.initializer === current) return true;
+  if (parent.type !== "VariableDeclarator" || parent.init !== current) return false;
+  const id = parent.id;
+  return parent.parent?.type === "VariableDeclaration" && parent.parent.kind === "const" && typeof id === "object" && id !== null && "type" in id && id.type === "Identifier";
+}
+function isSyntacticString(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (parent.type === "ImportDeclaration" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportAllDeclaration" || parent.type === "ImportExpression" || parent.type === "TSLiteralType" || parent.type === "TSExternalModuleReference") {
+    return true;
+  }
+  if (parent.type === "ExpressionStatement" && typeof parent.directive === "string") return true;
+  if ((parent.type === "Property" || parent.type === "MethodDefinition") && parent.key === node && parent.computed === false) {
+    return true;
+  }
+  return false;
+}
+var noInlineRuntimeLiteralRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: { description: "Require named runtime string and numeric values except inside JSX className props." }
+  },
+  create(context) {
+    const root = sourceRootOf(context);
+    const file = path40.resolve(context.filename);
+    if (!file.startsWith(root + path40.sep) || !isProductionSource(file, root)) return {};
+    return {
+      Literal(node) {
+        if (typeof node.value !== "string" && typeof node.value !== "number" && typeof node.value !== "bigint" && !("bigint" in node && typeof node.bigint === "string")) {
+          return;
+        }
+        if (typeof node.value === "string" && isClassNameProp(node) || isNamedValue(node) || isSyntacticString(node)) {
+          return;
+        }
+        context.report({ node, message: MESSAGE2 });
+      },
+      TemplateLiteral(node) {
+        if (isClassNameProp(node) || isNamedValue(node)) return;
+        if (node.quasis.every((quasi) => quasi.value.raw === "")) return;
+        context.report({ node, message: MESSAGE2 });
+      },
+      JSXText(node) {
+        if (!("value" in node) || typeof node.value !== "string" || node.value.trim().length === 0) return;
+        context.report({ node, message: MESSAGE2 });
+      }
+    };
+  }
+};
+
 // eslint/rules/no-literal-inline-style.ts
 function isStaticValue(value) {
   if (value.type === "Literal") {
@@ -5169,8 +5471,8 @@ var noLiteralInlineStyleRule = {
 };
 
 // eslint/rules/no-mixed-concerns.ts
-import { readFileSync as readFileSync8 } from "fs";
-import path39 from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import path41 from "path";
 var noMixedConcernsRule = {
   meta: {
     schema: [],
@@ -5194,7 +5496,7 @@ var noMixedConcernsRule = {
         if (components.length > 1) return;
         const componentName = components[0]?.name;
         if (!componentName) return;
-        const file = path39.resolve(context.filename);
+        const file = path41.resolve(context.filename);
         const sourceRoot = sourceRootOf(context);
         const index = getProjectIndex(sourceRoot);
         const componentConsumers = index?.symbolConsumers.get(symbolKey(file, componentName)) ?? /* @__PURE__ */ new Set();
@@ -5238,7 +5540,7 @@ var noMixedConcernsRule = {
               continue;
             }
             const target = typeof statement.source?.value === "string" ? resolveSpecifier(file, statement.source.value, sourceRoot) : void 0;
-            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync8(target, "utf8"), target).map((component) => component.name) : [];
+            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync9(target, "utf8"), target).map((component) => component.name) : [];
             for (const specifier of statement.specifiers) {
               if (/^type\b/.test(context.sourceCode.getText(specifier))) continue;
               if (specifier.local.type !== "Identifier") continue;
@@ -5272,11 +5574,11 @@ var noMixedConcernsRule = {
 };
 
 // eslint/rules/no-redundant-alias.ts
-import path41 from "path";
+import path43 from "path";
 
 // eslint/rules/contract-ownership.ts
-import path40 from "path";
-import ts7 from "typescript";
+import path42 from "path";
+import ts8 from "typescript";
 function isTsProgram(value) {
   return typeof value === "object" && value !== null && "getTypeChecker" in value && typeof value.getTypeChecker === "function" && "getSourceFiles" in value && typeof value.getSourceFiles === "function";
 }
@@ -5294,8 +5596,8 @@ function normalizePath(value) {
   return value.replaceAll("\\", "/").toLowerCase();
 }
 function isWithin2(root, file) {
-  const relative = path40.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path40.isAbsolute(relative);
+  const relative = path42.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path42.isAbsolute(relative);
 }
 function mergeOwnership(values) {
   if (values.length === 0 || values.includes("unknown")) return "unknown";
@@ -5310,11 +5612,11 @@ function endpointOwnership(pathValue) {
   return "unknown";
 }
 function resolvedSymbol(checker, symbol) {
-  return symbol.flags === ts7.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
 function propertyName3(node) {
   if (!node) return void 0;
-  if (ts7.isIdentifier(node) || ts7.isStringLiteral(node) || ts7.isNumericLiteral(node)) return node.text;
+  if (ts8.isIdentifier(node) || ts8.isStringLiteral(node) || ts8.isNumericLiteral(node)) return node.text;
   return void 0;
 }
 var ContractOwnershipIndex = class {
@@ -5338,7 +5640,7 @@ var ContractOwnershipIndex = class {
     }
     if (declarations.length > 0) return this.endpointFromDeclarations(declarations);
     let object;
-    if (ts7.isPropertyAccessExpression(node) || ts7.isElementAccessExpression(node)) object = node.expression;
+    if (ts8.isPropertyAccessExpression(node) || ts8.isElementAccessExpression(node)) object = node.expression;
     if (!object) return { kind: "missing", ownership: "unknown" };
     const type = this.checker.getTypeAtLocation(object);
     const typeDeclarations = this.typeDeclarations(type);
@@ -5346,7 +5648,7 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(typeDeclarations);
   }
   sourceBinding(node, name) {
-    if (!ts7.isVariableDeclaration(node) || !node.initializer) {
+    if (!ts8.isVariableDeclaration(node) || !node.initializer) {
       return { kind: "missing", ownership: "unknown" };
     }
     const sourceType = this.checker.getTypeAtLocation(node.initializer);
@@ -5355,11 +5657,11 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   targetProperty(node, name) {
-    if (!ts7.isPropertyAssignment(node) && !ts7.isShorthandPropertyAssignment(node)) {
+    if (!ts8.isPropertyAssignment(node) && !ts8.isShorthandPropertyAssignment(node)) {
       return { kind: "missing", ownership: "unknown" };
     }
     const object = node.parent;
-    if (!ts7.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
+    if (!ts8.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
     const contextualType = this.checker.getContextualType(object);
     if (!contextualType) return { kind: "missing", ownership: "unknown" };
     const declarations = this.propertyDeclarations(contextualType, name);
@@ -5367,8 +5669,8 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   memberNameSymbol(node) {
-    if (ts7.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
-    if (ts7.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
+    if (ts8.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
+    if (ts8.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
     return void 0;
   }
   propertyDeclarations(type, name) {
@@ -5398,14 +5700,14 @@ var ContractOwnershipIndex = class {
     if (declarations.some((declaration) => this.isDataContractField(declaration))) {
       return { kind: "data-contract", ownership };
     }
-    if (declarations.some((declaration) => ts7.isPropertySignature(declaration) || ts7.isPropertyDeclaration(declaration))) {
+    if (declarations.some((declaration) => ts8.isPropertySignature(declaration) || ts8.isPropertyDeclaration(declaration))) {
       return { kind: "typed-local", ownership };
     }
     return { kind: "non-contract", ownership };
   }
   isDataContractField(declaration) {
     if (this.isZodSchemaField(declaration)) return true;
-    if (!ts7.isPropertySignature(declaration) && !ts7.isPropertyDeclaration(declaration)) return false;
+    if (!ts8.isPropertySignature(declaration) && !ts8.isPropertyDeclaration(declaration)) return false;
     const fileName = normalizePath(declaration.getSourceFile().fileName);
     return /(?:^|\/)database(?:[-.]generated)?\.ts$/u.test(fileName);
   }
@@ -5414,10 +5716,10 @@ var ContractOwnershipIndex = class {
     return this.checker.getPropertyOfType(type, "_zod") !== void 0 && this.checker.getPropertyOfType(type, "parse") !== void 0 && this.checker.getPropertyOfType(type, "safeParse") !== void 0;
   }
   isZodSchemaField(declaration) {
-    if (!ts7.isPropertyAssignment(declaration)) return false;
+    if (!ts8.isPropertyAssignment(declaration)) return false;
     let current = declaration.parent;
-    while (!ts7.isSourceFile(current)) {
-      if (ts7.isVariableDeclaration(current) && ts7.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
+    while (!ts8.isSourceFile(current)) {
+      if (ts8.isVariableDeclaration(current) && ts8.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
         return true;
       }
       current = current.parent;
@@ -5435,12 +5737,12 @@ var ContractOwnershipIndex = class {
     const normalized = normalizePath(fileName);
     if (/\/typescript\/lib\/lib\.[^/]+\.d\.ts$/u.test(normalized)) return "platform";
     if (normalized.includes("/node_modules/")) return "third-party";
-    if (isWithin2(this.cwd, path40.resolve(fileName))) return "first-party";
+    if (isWithin2(this.cwd, path42.resolve(fileName))) return "first-party";
     return "unknown";
   }
   schemaOwnership(declaration) {
     let current = declaration;
-    while (!ts7.isSourceFile(current)) {
+    while (!ts8.isSourceFile(current)) {
       const ownership = this.schemaNodeOwnership.get(current);
       if (ownership !== void 0) return ownership;
       current = current.parent;
@@ -5449,31 +5751,31 @@ var ContractOwnershipIndex = class {
   }
   indexApiContracts() {
     for (const sourceFile of this.program.getSourceFiles()) {
-      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path40.resolve(sourceFile.fileName))) continue;
+      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path42.resolve(sourceFile.fileName))) continue;
       const visit = (node) => {
-        if (ts7.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
-        ts7.forEachChild(node, visit);
+        if (ts8.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
+        ts8.forEachChild(node, visit);
       };
       visit(sourceFile);
     }
   }
   isDefineApiContractCall(node) {
-    if (ts7.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
-    return ts7.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
+    if (ts8.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
+    return ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
   }
   indexApiContractCall(node) {
     const argument = node.arguments[0];
-    if (!argument || !ts7.isObjectLiteralExpression(argument)) return;
+    if (!argument || !ts8.isObjectLiteralExpression(argument)) return;
     let pathExpression;
     const schemaExpressions = [];
     for (const property of argument.properties) {
-      if (ts7.isPropertyAssignment(property)) {
+      if (ts8.isPropertyAssignment(property)) {
         const name = propertyName3(property.name);
         if (name === "path") pathExpression = property.initializer;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.initializer);
         continue;
       }
-      if (ts7.isShorthandPropertyAssignment(property)) {
+      if (ts8.isShorthandPropertyAssignment(property)) {
         const name = property.name.text;
         if (name === "path") pathExpression = property.name;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.name);
@@ -5487,13 +5789,13 @@ var ContractOwnershipIndex = class {
   }
   staticString(node, seen) {
     if (!node) return void 0;
-    if (ts7.isStringLiteralLike(node)) return node.text;
-    if (ts7.isIdentifier(node)) {
+    if (ts8.isStringLiteralLike(node)) return node.text;
+    if (ts8.isIdentifier(node)) {
       const symbol = this.checker.getSymbolAtLocation(node);
       if (!symbol || seen.has(symbol)) return void 0;
       seen.add(symbol);
       for (const declaration of resolvedSymbol(this.checker, symbol).declarations ?? []) {
-        if (ts7.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts8.isVariableDeclaration(declaration) && declaration.initializer) {
           const value = this.staticString(declaration.initializer, seen);
           if (value !== void 0) return value;
         }
@@ -5511,20 +5813,20 @@ var ContractOwnershipIndex = class {
         this.followSchemaDeclaration(declaration, ownership, seen);
       }
     }
-    ts7.forEachChild(node, (child) => {
+    ts8.forEachChild(node, (child) => {
       this.markSchemaExpression(child, ownership, seen);
     });
   }
   schemaReferenceSymbol(node) {
-    if (ts7.isIdentifier(node)) {
+    if (ts8.isIdentifier(node)) {
       if (!node.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node);
     }
-    if (ts7.isPropertyAccessExpression(node)) {
+    if (ts8.isPropertyAccessExpression(node)) {
       if (!node.name.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.name);
     }
-    if (ts7.isElementAccessExpression(node) && ts7.isStringLiteralLike(node.argumentExpression)) {
+    if (ts8.isElementAccessExpression(node) && ts8.isStringLiteralLike(node.argumentExpression)) {
       if (!node.argumentExpression.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.argumentExpression);
     }
@@ -5532,15 +5834,15 @@ var ContractOwnershipIndex = class {
   }
   followSchemaDeclaration(declaration, ownership, seen) {
     this.setSchemaOwnership(declaration, ownership);
-    if (ts7.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts8.isVariableDeclaration(declaration) && declaration.initializer) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts7.isPropertyAssignment(declaration)) {
+    if (ts8.isPropertyAssignment(declaration)) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts7.isShorthandPropertyAssignment(declaration)) {
+    if (ts8.isShorthandPropertyAssignment(declaration)) {
       const valueSymbol = this.checker.getShorthandAssignmentValueSymbol(declaration);
       if (!valueSymbol || seen.has(valueSymbol)) return;
       seen.add(valueSymbol);
@@ -5584,7 +5886,7 @@ function contractOwnershipResolver(context) {
 }
 
 // eslint/rules/no-redundant-alias.ts
-var DOC4 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
+var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 var VALUE_SENTINELS = /* @__PURE__ */ new Set(["undefined", "NaN", "Infinity"]);
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var FRAMEWORK_MAPPING_KEYS = /* @__PURE__ */ new Set(["default", "apiRoutePath"]);
@@ -5617,14 +5919,14 @@ function aliasedTypeName(annotation) {
 function aliasMessage(alias, source) {
   const aliasName = alias ?? "This declaration";
   const sourceName = source ?? "the original symbol";
-  return `"${aliasName}" only renames "${sourceName}". Use "${sourceName}" directly or rename the original symbol and its consumers. ${DOC4}`;
+  return `"${aliasName}" only renames "${sourceName}". Use "${sourceName}" directly or rename the original symbol and its consumers. ${DOC5}`;
 }
 function bindingAliasMessage(alias, source) {
-  return `"${alias}" renames "${source}" while creating a binding. Keep the original name and map it only at the object boundary. ${DOC4}`;
+  return `"${alias}" renames "${source}" while creating a binding. Keep the original name and map it only at the object boundary. ${DOC5}`;
 }
 function objectPropertyMessage(propertyName5, source) {
-  if (source === propertyName5) return `Use property shorthand for "${propertyName5}". ${DOC4}`;
-  return `"${propertyName5}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC4}`;
+  if (source === propertyName5) return `Use property shorthand for "${propertyName5}". ${DOC5}`;
+  return `"${propertyName5}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC5}`;
 }
 function normalizePropertyName(name) {
   return name.replace(/[-_\s]/g, "").toLowerCase();
@@ -5655,10 +5957,10 @@ function isInsideSchemaDeclaration(node) {
   return false;
 }
 function semanticMappingMessage(propertyName5, sourcePropertyName) {
-  return `"${propertyName5}" maps from "${sourcePropertyName}" between first-party contracts. Use one canonical field name across the contracts. ${DOC4}`;
+  return `"${propertyName5}" maps from "${sourcePropertyName}" between first-party contracts. Use one canonical field name across the contracts. ${DOC5}`;
 }
 function unknownContractOwnershipMessage(propertyName5, sourcePropertyName) {
-  return `Cannot determine contract ownership for mapping "${propertyName5}" from "${sourcePropertyName}". Define or propagate a concrete contract, make the boundary schema explicit, or connect a mirrored external schema to its defineApiContract. ${DOC4}`;
+  return `Cannot determine contract ownership for mapping "${propertyName5}" from "${sourcePropertyName}". Define or propagate a concrete contract, make the boundary schema explicit, or connect a mirrored external schema to its defineApiContract. ${DOC5}`;
 }
 function destructuredBindingSource(context, identifier) {
   const initialScope = context.sourceCode.getScope(identifier);
@@ -5720,7 +6022,7 @@ var noRedundantAliasRule = {
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") return;
         if (node.init.type === "Identifier") {
           const exported = declaration.parent.type === "ExportNamedDeclaration";
-          const frameworkRouteAlias = path41.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
+          const frameworkRouteAlias = path43.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
           if (frameworkRouteAlias || VALUE_SENTINELS.has(node.init.name)) return;
           context.report({
             node,
@@ -5838,7 +6140,7 @@ var noRedundantAliasRule = {
           const source = specifier.local.name;
           const alias = specifier.exported.name;
           if (source === alias) continue;
-          const frameworkRouteAlias = path41.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          const frameworkRouteAlias = path43.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
           if (frameworkRouteAlias) continue;
           context.report({
             node: specifier,
@@ -5863,7 +6165,7 @@ var noRedundantAliasRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path42 from "path";
+import path44 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -5873,7 +6175,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path42.resolve(context.filename);
+    const filename = path44.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -5882,7 +6184,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path42.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path44.basename(target).startsWith("index.")) continue;
           context.report({
             node,
             message: `Import utilities directly instead of through "${specifier}". See docs/next-codebase-guide/rules/utilities-rule.md`
@@ -5902,10 +6204,10 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path42.sep}src${path42.sep}`;
+  const marker = `${path44.sep}src${path44.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path42.resolve(context.cwd ?? process.cwd(), "src");
+  return path44.resolve(context.cwd ?? process.cwd(), "src");
 }
 
 // eslint/rules/package-json/exact-version.ts
@@ -6123,8 +6425,8 @@ var nextjsStackRule = {
 };
 
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync5, readFileSync as readFileSync9 } from "fs";
-import path43 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
+import path45 from "path";
 function memberName5(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -6194,7 +6496,7 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit:coverage" script that runs Vitest with coverage.'
           });
         }
-        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path43.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path45.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -6202,7 +6504,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync9(path43.join(context.cwd, configName), "utf8");
+        const content = readFileSync10(path45.join(context.cwd, configName), "utf8");
         for (const metric of THRESHOLD_METRICS) {
           if (!new RegExp(`\\b${metric}\\s*:\\s*[1-9]\\d*`).test(content)) {
             context.report({ node, message: `${configName} must set a coverage threshold above zero for ${metric}.` });
@@ -6248,8 +6550,8 @@ var nextjsPackageJsonRules = {
 };
 
 // eslint/rules/prefer-enum.ts
-import path44 from "path";
-import ts8 from "typescript";
+import path46 from "path";
+import ts9 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -6303,13 +6605,13 @@ function isLiteralTupleAssertion(node) {
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
 function isTsLiteralTupleDeclaration(declaration) {
-  if (!ts8.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  if (!ts9.isVariableDeclaration(declaration) || !declaration.initializer) return false;
   const init = declaration.initializer;
-  if (!ts8.isAsExpression(init) || !ts8.isTypeReferenceNode(init.type) || !ts8.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts8.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
+  if (!ts9.isAsExpression(init) || !ts9.isTypeReferenceNode(init.type) || !ts9.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts9.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
     return false;
   }
   const values = init.expression.elements.map(
-    (element) => ts8.isStringLiteral(element) || ts8.isNumericLiteral(element) ? element.text : void 0
+    (element) => ts9.isStringLiteral(element) || ts9.isNumericLiteral(element) ? element.text : void 0
   );
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
@@ -6322,9 +6624,9 @@ var preferEnumRule = {
     }
   },
   create(context) {
-    const filename = path44.resolve(context.filename);
+    const filename = path46.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path44.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path46.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
     const literalTuples = /* @__PURE__ */ new Set();
     const enumTupleUses = [];
@@ -6338,7 +6640,7 @@ var preferEnumRule = {
       const checker = services.program.getTypeChecker();
       const symbol = checker.getSymbolAtLocation(tsNode);
       if (!symbol) return false;
-      const original = symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const original = symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
     }
     return {
@@ -6433,8 +6735,8 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
-import ts9 from "typescript";
-var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
+import ts10 from "typescript";
+var DOC6 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 function hasTypeAnnotation(identifier) {
   return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
 }
@@ -6526,8 +6828,8 @@ function enumValueResolver(context) {
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
   const isEnumSymbol = (symbol) => {
-    const resolved = symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).some((declaration) => ts9.isEnumDeclaration(declaration));
+    const resolved = symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts10.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -6543,18 +6845,18 @@ function detachableCallResolver(context) {
   if (!services) return () => false;
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
-  const isUnboundFunctionType = (type) => ts9.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts9.isIdentifier(parameter.name) && parameter.name.text === "this");
+  const isUnboundFunctionType = (type) => ts10.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts10.isIdentifier(parameter.name) && parameter.name.text === "this");
   return (member) => {
     const node = nodeMap.get(member);
-    if (!node || !ts9.isPropertyAccessExpression(node)) return false;
+    if (!node || !ts10.isPropertyAccessExpression(node)) return false;
     const symbol = checker.getSymbolAtLocation(node.name);
     const declarations = symbol?.declarations;
     if (!declarations?.length) return false;
     return declarations.every((declaration) => {
-      if (ts9.isPropertySignature(declaration) || ts9.isPropertyDeclaration(declaration)) {
-        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts9.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts9.isArrowFunction(declaration.initializer);
+      if (ts10.isPropertySignature(declaration) || ts10.isPropertyDeclaration(declaration)) {
+        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts10.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts10.isArrowFunction(declaration.initializer);
       }
-      if (ts9.isPropertyAssignment(declaration)) return ts9.isArrowFunction(declaration.initializer);
+      if (ts10.isPropertyAssignment(declaration)) return ts10.isArrowFunction(declaration.initializer);
       return false;
     });
   };
@@ -6625,7 +6927,7 @@ function recordDestructuringUsage(context, scope, declaration, isEnumValue) {
 }
 function scopeUsageMessage(sourceText, propertyNames) {
   const names = [...propertyNames].map((name) => `"${name}"`).join(", ");
-  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC5}`;
+  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC6}`;
 }
 function hasBinding(context, node, name) {
   const initialScope = context.sourceCode.getScope(node);
@@ -6743,19 +7045,19 @@ function declarationTerminator(context, declaration) {
   return context.sourceCode.getText(declaration).trimEnd().endsWith(";") ? ";" : "";
 }
 function singlePropertyMessage(binding) {
-  return `"${binding.propertyName}" is the only property bound from "${binding.sourceText}". Read "${binding.sourceText}.${binding.propertyName}" directly instead of creating a local binding. ${DOC5}`;
+  return `"${binding.propertyName}" is the only property bound from "${binding.sourceText}". Read "${binding.sourceText}.${binding.propertyName}" directly instead of creating a local binding. ${DOC6}`;
 }
 function groupMessage(bindings) {
   const firstBinding = bindings[0];
-  if (!firstBinding) return `Use one object destructuring declaration. ${DOC5}`;
+  if (!firstBinding) return `Use one object destructuring declaration. ${DOC6}`;
   const names = bindings.map(({ localName }) => `"${localName}"`).join(", ");
-  return `${names} are derived directly from properties of "${firstBinding.sourceText}". Use one object destructuring declaration. ${DOC5}`;
+  return `${names} are derived directly from properties of "${firstBinding.sourceText}". Use one object destructuring declaration. ${DOC6}`;
 }
 function repeatedDestructuringMessage(group) {
   const first = group[0];
-  if (!first) return `Combine repeated destructuring into one declaration. ${DOC5}`;
+  if (!first) return `Combine repeated destructuring into one declaration. ${DOC6}`;
   const names = group.flatMap(({ localNames }) => localNames).map((name) => `"${name}"`).join(", ");
-  return `${names} destructure the same source "${first.sourceText}" repeatedly. Combine them into one object destructuring declaration. ${DOC5}`;
+  return `${names} destructure the same source "${first.sourceText}" repeatedly. Combine them into one object destructuring declaration. ${DOC6}`;
 }
 var preferObjectDestructuringRule = {
   meta: {
@@ -6873,7 +7175,7 @@ ${indentation}`;
           const sourceText = context.sourceCode.getText(declarator.init);
           context.report({
             node: declarator.id,
-            message: `"${sourceText}" is an enum. Keep enum member accesses qualified instead of destructuring it. ${DOC5}`
+            message: `"${sourceText}" is an enum. Keep enum member accesses qualified instead of destructuring it. ${DOC6}`
           });
         }
         recordDestructuringUsage(context, currentUsageScope(), node, isEnumValue);
@@ -6974,7 +7276,7 @@ ${indentation}`;
 };
 
 // eslint/rules/pure-function-extract.ts
-import path45 from "path";
+import path47 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -7039,12 +7341,12 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    const isRouteFile = path45.basename(filename) === "route.ts";
+    const isRouteFile = path47.basename(filename) === "route.ts";
     const isComponentFile = filename.endsWith(".tsx") || filename.endsWith(".jsx");
     const sourceRoot = sourceRootOf(context);
-    const relative = path45.relative(sourceRoot, filename);
+    const relative = path47.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path45.sep);
+    const segments = relative.split(path47.sep);
     const folders = segments.slice(0, -1);
     const isHookSupportFile = folders.includes("hooks") && /\.(?:[cm]?[jt]s)$/.test(filename);
     if (!isComponentFile && !isRouteFile && !isHookSupportFile) return {};
@@ -7104,16 +7406,15 @@ var pureFunctionExtractRule = {
 };
 
 // eslint/rules/repeated-numeric-value.ts
-import path46 from "path";
-var ignoredValues = /* @__PURE__ */ new Set([-1, 0, 1]);
+import path48 from "path";
 function isNonProductionFile(file, sourceRoot) {
-  const relative = path46.relative(sourceRoot, file);
-  const segments = relative.split(path46.sep);
-  const basename = path46.basename(file);
+  const relative = path48.relative(sourceRoot, file);
+  const segments = relative.split(path48.sep);
+  const basename = path48.basename(file);
   return /\.(?:test|spec|mock)\.[^.]+$/.test(basename) || segments.some((segment) => segment === "__tests__" || segment === "__mocks__" || segment === "mocks");
 }
 function isCanonicalConstantFile(file, sourceRoot) {
-  const segments = path46.relative(sourceRoot, file).split(path46.sep);
+  const segments = path48.relative(sourceRoot, file).split(path48.sep);
   return segments.includes("constants") || segments[0] === "config";
 }
 function groupKey(literal) {
@@ -7129,7 +7430,7 @@ var repeatedNumericValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path46.resolve(context.filename);
+    const file = path48.resolve(context.filename);
     if (isNonProductionFile(file, sourceRoot) || isCanonicalConstantFile(file, sourceRoot)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
@@ -7139,7 +7440,6 @@ var repeatedNumericValueRule = {
     for (const [moduleFile, parsedModule] of index.modules) {
       if (isNonProductionFile(moduleFile, sourceRoot)) continue;
       for (const literal of parsedModule.namedNumericLiterals) {
-        if (ignoredValues.has(literal.value)) continue;
         const key = groupKey(literal);
         const files = filesByGroup.get(key) ?? /* @__PURE__ */ new Set();
         files.add(moduleFile);
@@ -7150,7 +7450,6 @@ var repeatedNumericValueRule = {
       Program(node) {
         const reported = /* @__PURE__ */ new Set();
         for (const literal of currentModule.namedNumericLiterals) {
-          if (ignoredValues.has(literal.value)) continue;
           const key = groupKey(literal);
           if (reported.has(key)) continue;
           const files = filesByGroup.get(key);
@@ -7168,220 +7467,10 @@ var repeatedNumericValueRule = {
 };
 
 // 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;
-}
+import path50 from "path";
 
 // eslint/rules/imported-enum-literals.ts
-import path48 from "path";
+import path49 from "path";
 import ts11 from "typescript";
 var columnMethods2 = /* @__PURE__ */ new Set([
   "eq",
@@ -7403,8 +7492,8 @@ function memberName6(name) {
   return void 0;
 }
 function isWithin3(root, file) {
-  const relative = path48.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path48.isAbsolute(relative);
+  const relative = path49.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path49.isAbsolute(relative);
 }
 function domainOf(name) {
   if (name.endsWith("ColumnEnum")) return "column";
@@ -7424,7 +7513,7 @@ function importedEnums(file, checker, sourceRoot, importedNames) {
       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);
+        const declarationFile = path49.resolve(declaration.getSourceFile().fileName);
         if (!isWithin3(sourceRoot, declarationFile)) continue;
         const domain = domainOf(declaration.name.text);
         if (!domain) continue;
@@ -7464,7 +7553,7 @@ function domainForUse(node) {
   return void 0;
 }
 function importedEnumLiteralUses(context, root) {
-  const filename = path48.resolve(context.filename);
+  const filename = path49.resolve(context.filename);
   if (!isWithin3(root, filename)) return [];
   const services = typedParserServices(context.sourceCode.parserServices);
   if (!services) return [];
@@ -7504,7 +7593,8 @@ function importedEnumLiteralUses(context, root) {
 }
 
 // eslint/rules/repeated-semantic-literal.ts
-var DOC6 = "See docs/next-codebase-guide/rules/constants-rule.md";
+var DOC7 = "See docs/next-codebase-guide/rules/constants-rule.md";
+var closedDomainFamilies = /* @__PURE__ */ new Set(["api-route", "event", "storage"]);
 function canonicalMatches(use, canonical, sourceRoot) {
   if (use.kind !== canonical.kind || use.value !== canonical.value) return false;
   const name = canonical.owner ?? canonical.name;
@@ -7517,7 +7607,7 @@ function canonicalMatches(use, canonical, sourceRoot) {
     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 location === featureOf(use.file, sourceRoot) || path50.relative(sourceRoot, canonical.file).split(path50.sep)[0] === "constants";
   }
   return false;
 }
@@ -7531,14 +7621,14 @@ 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}`;
+    const location = path50.relative(root, existingRouteEnum.file).replaceAll(path50.sep, "/");
+    return `The route ${formatValue(use)} repeats; add a member to existing ${existingRouteEnum.owner} in src/${location} and reuse it. ${DOC7}`;
   }
   if (count === 1) {
-    return `The ${kind} literal ${formatValue(use)} repeats in the same semantic role in this file. Extract a file-local const. ${DOC6}`;
+    return `The ${kind} literal ${formatValue(use)} repeats in the same semantic role in this file. Extract a file-local const. ${DOC7}`;
   }
   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}`;
+  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. ${DOC7}`;
 }
 var repeatedSemanticLiteralRule = {
   meta: {
@@ -7550,7 +7640,7 @@ var repeatedSemanticLiteralRule = {
   },
   create(context) {
     const root = sourceRootOf(context);
-    const file = path49.resolve(context.filename);
+    const file = path50.resolve(context.filename);
     if (!isProductionSource(file, root)) return {};
     const project = getProjectIndex(root);
     if (!project?.modules.has(file)) return {};
@@ -7577,6 +7667,13 @@ var repeatedSemanticLiteralRule = {
     for (const [role, values] of routeValues) {
       if (values.size >= 2) duplicatedApiRoutes.add(role);
     }
+    const closedDomains = /* @__PURE__ */ new Map();
+    for (const use of index.uses) {
+      if (use.kind !== "string" || !closedDomainFamilies.has(use.family)) continue;
+      const values = closedDomains.get(use.role) ?? /* @__PURE__ */ new Set();
+      values.add(String(use.value));
+      closedDomains.set(use.role, values);
+    }
     const routeDomains = /* @__PURE__ */ new Map();
     for (const canonical of index.canonicals) {
       if (canonical.owner && /^ApiRoute(?:Enum)?$/.test(canonical.owner)) {
@@ -7588,11 +7685,11 @@ var repeatedSemanticLiteralRule = {
     return {
       Program(node) {
         for (const use of imported) {
-          const relative = path49.relative(root, use.sourceFile).replaceAll(path49.sep, "/");
+          const relative = path50.relative(root, use.sourceFile).replaceAll(path50.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}`
+            message: `Reuse ${use.reference} from src/${relative} instead of raw ${JSON.stringify(use.value)}. ${DOC7}`
           });
         }
         for (const use of current) {
@@ -7603,18 +7700,37 @@ var repeatedSemanticLiteralRule = {
           if (candidates.length === 1) {
             const canonical = candidates[0];
             if (!canonical) continue;
-            const relative = path49.relative(root, canonical.file).replaceAll(path49.sep, "/");
+            const relative = path50.relative(root, canonical.file).replaceAll(path50.sep, "/");
             context.report({
               node,
               loc: { line: use.line, column: use.column },
-              message: `Reuse ${canonicalName(canonical)} from src/${relative} instead of raw ${formatValue(use)}. ${DOC6}`
+              message: `Reuse ${canonicalName(canonical)} from src/${relative} instead of raw ${formatValue(use)}. ${DOC7}`
             });
             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 (peers.length < 2) {
+            if (use.family === "api-route" && existingRouteEnum?.owner) {
+              const location = path50.relative(root, existingRouteEnum.file).replaceAll(path50.sep, "/");
+              context.report({
+                node,
+                loc: { line: use.line, column: use.column },
+                message: `The route ${formatValue(use)} belongs to existing ${existingRouteEnum.owner}; add a member in src/${location} and reuse it. ${DOC7}`
+              });
+              continue;
+            }
+            const domain = closedDomains.get(use.role);
+            if (domain && domain.size >= 2) {
+              context.report({
+                node,
+                loc: { line: use.line, column: use.column },
+                message: `The string literal ${formatValue(use)} is one of ${String(domain.size)} values in a closed ${use.family} domain. Declare the domain in a shared enum at the consumers' CCF and reuse it. ${DOC7}`
+              });
+            }
+            continue;
+          }
           if (use.kind === "number" && !use.family.startsWith("timer")) continue;
           context.report({
             node,
@@ -7809,7 +7925,7 @@ var repeatedStructureRule = {
 
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path50 from "path";
+import path51 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"];
@@ -7817,9 +7933,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 = path50.dirname(indexFile);
-  const direct = path50.resolve(directory, relative);
-  const candidates = path50.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path51.dirname(indexFile);
+  const direct = path51.resolve(directory, relative);
+  const candidates = path51.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -7832,9 +7948,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path50.resolve(context.filename);
-    if (!INDEX_NAMES.has(path50.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path50.basename(path50.dirname(filename)))) return {};
+    const filename = path51.resolve(context.filename);
+    if (!INDEX_NAMES.has(path51.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path51.basename(path51.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -7887,7 +8003,7 @@ var requireBarrelStarExportsRule = {
 };
 
 // eslint/rules/root-support-placement.ts
-import path51 from "path";
+import path52 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -7920,7 +8036,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path51.resolve(context.filename);
+    const file = path52.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -7966,7 +8082,7 @@ var rootSupportPlacementRule = {
 };
 
 // eslint/rules/route-handler-shape.ts
-import path52 from "path";
+import path53 from "path";
 import ts12 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
@@ -8051,7 +8167,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path52.basename(context.filename) !== "route.ts") return {};
+    if (path53.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -8110,7 +8226,7 @@ var routeHandlerShapeRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path53 from "path";
+import path54 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -8138,9 +8254,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path53.resolve(context.filename);
+    const filename = path54.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path53.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path54.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -8172,7 +8288,7 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path54 from "path";
+import path55 from "path";
 import ts13 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
@@ -8252,7 +8368,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path54.resolve(context.filename);
+    const filename = path55.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -8331,7 +8447,7 @@ function usesOutsideJsx(declaration, hook, children) {
 }
 
 // eslint/rules/source-under-src.ts
-import path55 from "path";
+import path56 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -8372,14 +8488,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path55.resolve(context.filename);
+    const filename = path56.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path55.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path56.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 = path55.basename(filename);
+      const basename = path56.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -8395,7 +8511,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path56 from "path";
+import path57 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -8406,7 +8522,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path56.resolve(context.filename);
+    const file = path57.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -8446,7 +8562,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path57 from "path";
+import path58 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -8471,7 +8587,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path57.resolve(context.filename);
+    const supportFile = path58.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -8525,7 +8641,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path58 from "path";
+import path59 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 = {
@@ -8537,12 +8653,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path58.resolve(context.filename);
-    const baseName = path58.basename(filename);
+    const filename = path59.resolve(context.filename);
+    const baseName = path59.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path58.basename(path58.dirname(filename));
+    const folder = path59.basename(path59.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path58.dirname(filename);
+    const directory = path59.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -8560,7 +8676,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path58.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path59.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -8739,11 +8855,11 @@ var baseLayerPairRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path61 from "path";
+import path62 from "path";
 
 // eslint/rules/tailwind/source-files.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
-import path59 from "path";
+import path60 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
@@ -8756,7 +8872,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path59.join(dir, entry);
+    const entryPath = path60.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -8764,7 +8880,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path59.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path60.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -8787,7 +8903,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path60 from "path";
+import path61 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -8801,25 +8917,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 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));
+  if (spec.startsWith("/")) return path61.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path61.resolve(path61.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path61.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path60.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path61.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(path60.normalize(global));
+  for (const global of globals) reachable.add(path61.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 = path60.normalize(target);
+      const normalized = path61.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -8831,7 +8947,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path60.normalize(target);
+      const normalized = path61.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -8839,8 +8955,8 @@ function buildStylesheetGraph(options) {
 }
 
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path61.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path61.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path62.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path62.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -8866,8 +8982,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path61.normalize(path61.resolve(context.filename));
-        const relative = path61.relative(sourceRoot, current);
+        const current = path62.normalize(path62.resolve(context.filename));
+        const relative = path62.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -8883,7 +8999,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path61.basename(current);
+          const basename = path62.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -8893,7 +9009,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path61.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path62.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -9382,7 +9498,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path62 from "path";
+import path63 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -9393,7 +9509,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path62.resolve(context.filename);
+    const file = path63.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -9534,7 +9650,7 @@ var uiStateRule = {
 // eslint/rules/unknown-utility.ts
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path63 from "path";
+import path64 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -9774,7 +9890,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path63.join(dir, entry);
+    const entryPath = path64.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -9782,7 +9898,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path63.extname(entry) === ".css" ? [entryPath] : [];
+    return path64.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -9793,10 +9909,10 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  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");
+  let directory = path64.dirname(fromFile);
+  while (directory !== path64.dirname(directory)) {
+    const packageRoot = path64.join(directory, "node_modules", packageName);
+    const manifestPath = path64.join(packageRoot, "package.json");
     if (existsSync6(manifestPath)) {
       try {
         const manifest = readFileSync12(manifestPath, "utf8");
@@ -9804,13 +9920,13 @@ function resolvePackageStylesheet(fromFile, specifier) {
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path63.resolve(packageRoot, target);
+        const resolved = path64.resolve(packageRoot, target);
         return existsSync6(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path63.dirname(directory);
+    directory = path64.dirname(directory);
   }
   return void 0;
 }
@@ -10061,7 +10177,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path64 from "path";
+import path65 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();
 }
@@ -10074,7 +10190,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path64.resolve(context.filename);
+    const filename = path65.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -10088,13 +10204,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path64.basename(filename, path64.extname(filename));
+    const actual = path65.basename(filename, path65.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path64.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path65.extname(filename).slice(1)}.`
         });
       }
     };
@@ -10102,7 +10218,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path65 from "path";
+import path66 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -10113,7 +10229,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path65.resolve(context.filename);
+    const file = path66.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -10135,7 +10251,7 @@ var valueExtractionRule = {
 
 // eslint/rules/vulyk/tracked-docs.ts
 import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
-import path66 from "path";
+import path67 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -10168,8 +10284,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path66.dirname(path66.resolve(context.filename));
-        const configPath = path66.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path67.dirname(path67.resolve(context.filename));
+        const configPath = path67.join(projectRoot, "vulyk.config.ts");
         if (!existsSync7(configPath)) {
           context.report({
             node,
@@ -10194,7 +10310,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path66.join(projectRoot, "AGENTS.md");
+        const agentsPath = path67.join(projectRoot, "AGENTS.md");
         if (!existsSync7(agentsPath)) {
           context.report({
             node,
@@ -10255,9 +10371,9 @@ var vulykRules = {
 // eslint/rules/with-response-helper.ts
 var HELPER3 = "withResponse";
 var ENTRY3 = "pasika/with-response";
-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}`;
+var DOC8 = "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 ${DOC8}`;
+var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC8}`;
 function isNamed3(node, name) {
   return node?.type === "Identifier" && node.name === name;
 }
@@ -10294,7 +10410,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path67 from "path";
+import path68 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -10313,10 +10429,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path67.resolve(context.filename);
-    const basename = path67.basename(filename);
+    const filename = path68.resolve(context.filename);
+    const basename = path68.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path67.dirname(filename);
+    const projectRoot = path68.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -10331,7 +10447,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path67.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path68.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -10349,13 +10465,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path67.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path68.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(path67.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path68.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."
@@ -10378,10 +10494,10 @@ function referencesZirka(sourceCode) {
 // eslint/rules/zod-fetch-helper.ts
 var HELPER4 = "zodFetch";
 var ENTRY4 = "pasika/zod-fetch";
-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 DOC9 = "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 ${DOC9}`;
+var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC9}`;
+var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC9}`;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 var TEST_FILE2 = /(?:^|[\\/])(?:__tests__|tests)[\\/]|[.](?:test|spec)[.][cm]?[jt]sx?$/;
 function isNamed4(node, name) {
@@ -10562,6 +10678,7 @@ var pasikaNextjsAppRules = {
   "util-file-name": utilFileNameRule,
   "no-util-barrel": noUtilBarrelRule,
   "no-redundant-alias": noRedundantAliasRule,
+  "no-inline-runtime-literal": noInlineRuntimeLiteralRule,
   "enforce-barrel-exports": enforceBarrelExportsRule,
   "require-barrel-star-exports": requireBarrelStarExportsRule,
   "config-extraction": configExtractionRule,
@@ -10653,6 +10770,12 @@ var pasikaAppLanguageOptions = {
     ecmaFeatures: { jsx: true }
   }
 };
+var pasikaTypeScriptFileLengthConfig = {
+  files: ["**/*.{cts,mts,ts,tsx}"],
+  languageOptions: pasikaAppLanguageOptions,
+  plugins: { pasika: pasikaPlugin },
+  rules: { "pasika/file-length": "error" }
+};
 var pasikaNextjsAppConfig = {
   files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
   languageOptions: pasikaAppLanguageOptions,
@@ -10725,7 +10848,12 @@ var documentationConfig = {
   language: "markdown/gfm",
   rules: Object.fromEntries(documentationRuleIds.map((id) => [id, "error"]))
 };
-var pasikaApp = [pasikaAppPackageJsonConfig, zirkaConfig, documentationConfig];
+var pasikaApp = [
+  pasikaAppPackageJsonConfig,
+  zirkaConfig,
+  documentationConfig,
+  pasikaTypeScriptFileLengthConfig
+];
 var pasikaNextjsAppWithDiagnostic = (preset) => {
   let checked = false;
   return new Proxy(preset, {