@hominis/fireforge 0.11.2 → 0.13.0

package/dist/src/core/patch-lint-jsdoc.js

@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * AST-based JSDoc validation for exported declarations in `.sys.mjs`
+ * modules. Uses Acorn (already a runtime dependency) to parse the
+ * module and inspects JSDoc comments via the `onComment` callback.
+ *
+ * Separated from `patch-lint.ts` to keep both files within the
+ * project's per-file line budget.
+ */
+import { parseModule } from './ast-utils.js';
+// ---------------------------------------------------------------------------
+// JSDoc comment helpers
+// ---------------------------------------------------------------------------
+function isJsDocComment(comment) {
+    return comment.type === 'Block' && comment.value.startsWith('*');
+}
+/**
+ * Finds the JSDoc comment immediately preceding `declStart` in the
+ * source. "Immediately" means only whitespace and newlines may appear
+ * between the comment's closing delimiter and the declaration.
+ */
+function findAttachedJsDoc(comments, declStart, source) {
+    for (let i = comments.length - 1; i >= 0; i--) {
+        const c = comments[i];
+        if (!c || !isJsDocComment(c))
+            continue;
+        const commentEnd = c.end;
+        if (commentEnd > declStart)
+            continue;
+        const between = source.slice(commentEnd, declStart);
+        if (/^\s*$/.test(between))
+            return c;
+        break;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// JSDoc tag parsing
+// ---------------------------------------------------------------------------
+function extractParamNames(jsDoc) {
+    const names = [];
+    const paramPattern = /@param\s+(?:\{[^}]*\}\s+)?(\w+)/g;
+    let m;
+    while ((m = paramPattern.exec(jsDoc)) !== null) {
+        if (m[1])
+            names.push(m[1]);
+    }
+    return names;
+}
+function hasReturnsTag(jsDoc) {
+    return /@returns?\b/.test(jsDoc);
+}
+// ---------------------------------------------------------------------------
+// Return-statement detection
+// ---------------------------------------------------------------------------
+/**
+ * Returns true if any direct `ReturnStatement` in the function body
+ * has a non-null argument. Does not recurse into nested functions or
+ * arrow expressions which have their own return semantics.
+ */
+function functionReturnsValue(node) {
+    return walkForReturn(node.body);
+}
+function walkForReturn(node) {
+    if (node.type === 'ReturnStatement') {
+        return node.argument != null;
+    }
+    if (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression') {
+        return false;
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'type')
+            continue;
+        const val = node[key];
+        if (val && typeof val === 'object') {
+            if (Array.isArray(val)) {
+                for (const child of val) {
+                    if (child && typeof child === 'object' && 'type' in child) {
+                        if (walkForReturn(child))
+                            return true;
+                    }
+                }
+            }
+            else if ('type' in val) {
+                if (walkForReturn(val))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function findLocalDeclaration(body, name) {
+    for (const stmt of body) {
+        if (stmt.type === 'FunctionDeclaration') {
+            const fn = stmt;
+            if (fn.id.name === name)
+                return stmt;
+        }
+        else if (stmt.type === 'ClassDeclaration') {
+            const cls = stmt;
+            if (cls.id.name === name)
+                return stmt;
+        }
+        else if (stmt.type === 'VariableDeclaration') {
+            const varDecl = stmt;
+            for (const d of varDecl.declarations) {
+                if (d.id.type === 'Identifier' && d.id.name === name) {
+                    return varDecl;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Line number helpers
+// ---------------------------------------------------------------------------
+function lineAt(source, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < source.length; i++) {
+        if (source[i] === '\n')
+            line++;
+    }
+    return line;
+}
+// ---------------------------------------------------------------------------
+// Core validation
+// ---------------------------------------------------------------------------
+function validateFunctionDecl(fn, comments, source, issues, lookupStart) {
+    const name = fn.id.name;
+    const start = lookupStart !== undefined ? lookupStart : fn.start;
+    const line = lineAt(source, start);
+    const jsDoc = findAttachedJsDoc(comments, start, source);
+    if (!jsDoc) {
+        issues.push({
+            line,
+            check: 'missing-jsdoc',
+            message: `Exported function "${name}" at line ${line} is missing a JSDoc comment.`,
+        });
+        return;
+    }
+    const docText = jsDoc.value;
+    const actualParams = fn.params
+        .map((p) => (p.type === 'Identifier' ? p.name : null))
+        .filter((n) => n !== null);
+    if (actualParams.length > 0) {
+        const docParams = extractParamNames(docText);
+        for (const param of actualParams) {
+            if (!docParams.includes(param)) {
+                issues.push({
+                    line,
+                    check: 'jsdoc-param-mismatch',
+                    message: `Exported function "${name}" at line ${line}: @param "${param}" is missing or misnamed in JSDoc.`,
+                });
+            }
+        }
+    }
+    if (functionReturnsValue(fn) && !hasReturnsTag(docText)) {
+        issues.push({
+            line,
+            check: 'jsdoc-missing-returns',
+            message: `Exported function "${name}" at line ${line} returns a value but JSDoc is missing @returns.`,
+        });
+    }
+}
+function validateClassDecl(cls, comments, source, issues, lookupStart) {
+    const name = cls.id.name;
+    const start = lookupStart !== undefined ? lookupStart : cls.start;
+    const line = lineAt(source, start);
+    const jsDoc = findAttachedJsDoc(comments, start, source);
+    if (!jsDoc) {
+        issues.push({
+            line,
+            check: 'missing-jsdoc',
+            message: `Exported class "${name}" at line ${line} is missing a JSDoc comment.`,
+        });
+    }
+}
+function validateVariableDecl(varDecl, comments, source, issues, lookupStart) {
+    const start = lookupStart !== undefined ? lookupStart : varDecl.start;
+    const jsDoc = findAttachedJsDoc(comments, start, source);
+    if (jsDoc)
+        return; // has a JSDoc block — sufficient for constants
+    for (const decl of varDecl.declarations) {
+        const name = decl.id.type === 'Identifier' ? decl.id.name : '<destructured>';
+        const line = lineAt(source, start);
+        issues.push({
+            line,
+            check: 'missing-jsdoc',
+            message: `Exported constant "${name}" at line ${line} is missing a JSDoc comment.`,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Validates JSDoc on exported declarations in a `.sys.mjs` source file.
+ *
+ * @param source - File content
+ * @returns Array of JSDoc issues found
+ */
+export function validateExportJsDoc(source) {
+    const comments = [];
+    let ast;
+    try {
+        ast = parseModule(source, comments);
+    }
+    catch {
+        return [];
+    }
+    const issues = [];
+    const body = ast.body;
+    for (const node of body) {
+        if (node.type !== 'ExportNamedDeclaration')
+            continue;
+        const exportNode = node;
+        // Case 1: inline export declaration — JSDoc attaches to `export`
+        if (exportNode.declaration) {
+            const decl = exportNode.declaration;
+            const exportStart = exportNode.start;
+            if (decl.type === 'FunctionDeclaration') {
+                validateFunctionDecl(decl, comments, source, issues, exportStart);
+            }
+            else if (decl.type === 'ClassDeclaration') {
+                validateClassDecl(decl, comments, source, issues, exportStart);
+            }
+            else if (decl.type === 'VariableDeclaration') {
+                validateVariableDecl(decl, comments, source, issues, exportStart);
+            }
+            continue;
+        }
+        // Case 2: `export { foo, Bar }` — resolve back to local declarations
+        if (exportNode.specifiers.length > 0 && !exportNode.source) {
+            for (const spec of exportNode.specifiers) {
+                const local = spec.local;
+                if (local.type !== 'Identifier')
+                    continue;
+                const localName = local.name;
+                const localDecl = findLocalDeclaration(body, localName);
+                if (!localDecl)
+                    continue;
+                if (localDecl.type === 'FunctionDeclaration') {
+                    validateFunctionDecl(localDecl, comments, source, issues);
+                }
+                else if (localDecl.type === 'ClassDeclaration') {
+                    validateClassDecl(localDecl, comments, source, issues);
+                }
+                else {
+                    validateVariableDecl(localDecl, comments, source, issues);
+                }
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=patch-lint-jsdoc.js.map

package/dist/src/core/patch-lint-ownership.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Patch ownership resolution for `.sys.mjs` files.
+ *
+ * A file is "patch-owned" when it was created by the project's patch
+ * queue rather than being an upstream Firefox file that happens to be
+ * modified. This module computes the set of patch-owned `.sys.mjs`
+ * paths so lint rules can scope enforcement to project code only.
+ */
+import type { PatchQueueContext } from './patch-lint-cross.js';
+/**
+ * Returns the set of file paths that are patch-owned `.sys.mjs` files.
+ *
+ * A file is patch-owned if:
+ * 1. It is newly created in the current diff, OR
+ * 2. It was created by an existing patch already in the queue.
+ *
+ * When no queue context is provided the result is limited to (1),
+ * which matches the pre-ownership behavior and keeps callers that
+ * do not have access to the patches directory working correctly.
+ *
+ * @param currentNewFiles - Files newly created in the current diff
+ * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
+ * @returns Set of patch-owned `.sys.mjs` file paths
+ */
+export declare function resolvePatchOwnedSysMjs(currentNewFiles: Set<string>, patchQueueCtx?: PatchQueueContext): Set<string>;

package/dist/src/core/patch-lint-ownership.js

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch ownership resolution for `.sys.mjs` files.
+ *
+ * A file is "patch-owned" when it was created by the project's patch
+ * queue rather than being an upstream Firefox file that happens to be
+ * modified. This module computes the set of patch-owned `.sys.mjs`
+ * paths so lint rules can scope enforcement to project code only.
+ */
+import { collectNewFileCreatorsByPath } from './patch-lint-cross.js';
+/**
+ * Returns the set of file paths that are patch-owned `.sys.mjs` files.
+ *
+ * A file is patch-owned if:
+ * 1. It is newly created in the current diff, OR
+ * 2. It was created by an existing patch already in the queue.
+ *
+ * When no queue context is provided the result is limited to (1),
+ * which matches the pre-ownership behavior and keeps callers that
+ * do not have access to the patches directory working correctly.
+ *
+ * @param currentNewFiles - Files newly created in the current diff
+ * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
+ * @returns Set of patch-owned `.sys.mjs` file paths
+ */
+export function resolvePatchOwnedSysMjs(currentNewFiles, patchQueueCtx) {
+    const owned = new Set();
+    for (const file of currentNewFiles) {
+        if (file.endsWith('.sys.mjs')) {
+            owned.add(file);
+        }
+    }
+    if (patchQueueCtx) {
+        const creators = collectNewFileCreatorsByPath(patchQueueCtx);
+        for (const [file, owners] of creators) {
+            if (file.endsWith('.sys.mjs') && owners.length > 0) {
+                owned.add(file);
+            }
+        }
+    }
+    return owned;
+}
+//# sourceMappingURL=patch-lint-ownership.js.map

package/dist/src/core/patch-lint.d.ts

@@ -1,8 +1,17 @@
 import type { PatchLintIssue } from '../types/commands/index.js';
 import type { FireForgeConfig } from '../types/config.js';
 import { type CommentStyle } from './license-headers.js';
+export { runCheckJs } from './patch-lint-checkjs.js';
 export { buildPatchQueueContext, collectNewFileCreatorsByPath, type ExtractedSpecifier, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
+export { type JsDocCheck, type JsDocIssue, validateExportJsDoc } from './patch-lint-jsdoc.js';
+export { resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
+/**
+ * Returns true if the file path looks like a test file.
+ * Matches paths containing `/test/` or filenames starting with
+ * `browser_`, `test_`, or `xpcshell_` (all `.js`).
+ */
+export declare function isTestFile(file: string): boolean;
 /**
  * Detects comment style from file extension for license header checks.
  */
@@ -16,7 +25,7 @@ export declare function commentStyleForFile(file: string): CommentStyle | null;
  * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
  * @returns Array of lint issues found
  */
-export declare function lintPatchedCss(repoDir: string, affectedFiles: string[], diffContent?: string): Promise<PatchLintIssue[]>;
+export declare function lintPatchedCss(repoDir: string, affectedFiles: string[], diffContent?: string, config?: FireForgeConfig): Promise<PatchLintIssue[]>;
 /**
  * Checks new files for required license headers.
  *
@@ -34,9 +43,10 @@ export declare function lintNewFileHeaders(repoDir: string, newFiles: string[],
  * @param affectedFiles - File paths (relative to repoDir)
  * @param newFiles - Set of files that are newly created in this patch
  * @param config - Project configuration
+ * @param patchOwnedFiles - Optional set of patch-owned `.sys.mjs` paths for scoped JSDoc enforcement
  * @returns Array of lint issues
  */
-export declare function lintPatchedJs(repoDir: string, affectedFiles: string[], newFiles: Set<string>, config: FireForgeConfig): Promise<PatchLintIssue[]>;
+export declare function lintPatchedJs(repoDir: string, affectedFiles: string[], newFiles: Set<string>, config: FireForgeConfig, patchOwnedFiles?: Set<string>): Promise<PatchLintIssue[]>;
 /**
  * Checks that modifications to existing (non-new) JS/MJS files include at
  * least one `// BINARYNAME:` comment in the added lines.
@@ -67,6 +77,7 @@ export declare function lintModifiedFileHeaders(repoDir: string, affectedFiles:
  * @param affectedFiles - File paths (relative to repoDir) affected by the patch
  * @param diffContent - Raw unified diff string
  * @param config - Project configuration
+ * @param patchQueueCtx - Optional cross-patch context for ownership resolution
  * @returns Array of all lint issues found
  */
-export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig): Promise<PatchLintIssue[]>;
+export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig, patchQueueCtx?: import('./patch-lint-cross.js').PatchQueueContext): Promise<PatchLintIssue[]>;

package/dist/src/core/patch-lint.js

@@ -6,7 +6,10 @@ import { verbose } from '../utils/logger.js';
 import { hasRawCssColors, stripJsComments } from '../utils/regex.js';
 import { loadFurnaceConfig } from './furnace-config.js';
 import { getLicenseHeader, hasAnyLicenseHeader } from './license-headers.js';
+import { runCheckJs } from './patch-lint-checkjs.js';
 import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-diff.js';
+import { validateExportJsDoc } from './patch-lint-jsdoc.js';
+import { resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
 // ---------------------------------------------------------------------------
 // Cross-patch lint re-exports
 // ---------------------------------------------------------------------------
@@ -16,12 +19,23 @@ import { detectNewFilesInDiff, extractAddedLinesPerFile } from './patch-lint-dif
 // `patch-lint-cross.ts` so the per-patch and cross-patch rule bodies can
 // each stay within the project's per-file line budget. Re-export the
 // public surface so callers continue to import from a single module.
+export { runCheckJs } from './patch-lint-checkjs.js';
 export { buildPatchQueueContext, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
+export { validateExportJsDoc } from './patch-lint-jsdoc.js';
+export { resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 const JS_EXTENSIONS = ['.js', '.mjs', '.jsm'];
+const FILE_SIZE_THRESHOLDS = {
+    general: { notice: 500, warning: 750, error: 900 },
+    test: { notice: 1200, warning: 1400, error: 1600 },
+};
+const PATCH_LINE_THRESHOLDS = {
+    general: { notice: 800, warning: 1500, error: 3000 },
+    test: { notice: 1500, warning: 3000, error: 6000 },
+};
 /**
  * Returns true if the filename looks like a JS/MJS/JSM file.
  * Handles `.sys.mjs` as well.
@@ -29,6 +43,17 @@ const JS_EXTENSIONS = ['.js', '.mjs', '.jsm'];
 function isJsFile(file) {
     return JS_EXTENSIONS.some((ext) => file.endsWith(ext));
 }
+/**
+ * Returns true if the file path looks like a test file.
+ * Matches paths containing `/test/` or filenames starting with
+ * `browser_`, `test_`, or `xpcshell_` (all `.js`).
+ */
+export function isTestFile(file) {
+    if (file.includes('/test/'))
+        return true;
+    const basename = file.split('/').pop() ?? '';
+    return /^(?:browser_|test_|xpcshell_).*\.js$/.test(basename);
+}
 /**
  * Detects comment style from file extension for license header checks.
  */
@@ -53,7 +78,7 @@ export function commentStyleForFile(file) {
  * @param diffContent - Optional unified diff used to scope raw color checks to introduced lines
  * @returns Array of lint issues found
  */
-export async function lintPatchedCss(repoDir, affectedFiles, diffContent) {
+export async function lintPatchedCss(repoDir, affectedFiles, diffContent, config) {
     const cssFiles = affectedFiles.filter((f) => f.endsWith('.css'));
     if (cssFiles.length === 0)
         return [];
@@ -80,17 +105,29 @@ export async function lintPatchedCss(repoDir, affectedFiles, diffContent) {
         const rawCss = await readText(filePath);
         // Strip block comments before scanning
         const cssContent = rawCss.replace(/\/\*[\s\S]*?\*\//g, '');
-        const rawColorContent = addedLinesByFile
-            ? (addedLinesByFile.get(file) ?? []).join('\n').replace(/\/\*[\s\S]*?\*\//g, '')
-            : cssContent;
         // Check only introduced raw color values when diff context is available.
-        if (hasRawCssColors(rawColorContent)) {
-            issues.push({
-                file,
-                check: 'raw-color-value',
-                message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
-                severity: 'error',
-            });
+        // Skip files on the raw-color allowlist (exact path or basename match).
+        const allowlist = config?.patchLint?.rawColorAllowlist;
+        const isAllowlisted = allowlist?.some((entry) => file === entry || file.endsWith('/' + entry));
+        if (!isAllowlisted) {
+            // Strip lines with inline fireforge-ignore: raw-color-value suppression.
+            // Check against rawCss (before comment stripping) so the CSS comment marker is still present.
+            const sourceForSuppression = addedLinesByFile
+                ? (addedLinesByFile.get(file) ?? []).join('\n')
+                : rawCss;
+            const suppressedContent = sourceForSuppression
+                .split('\n')
+                .filter((line) => !line.includes('fireforge-ignore: raw-color-value'))
+                .join('\n')
+                .replace(/\/\*[\s\S]*?\*\//g, '');
+            if (hasRawCssColors(suppressedContent)) {
+                issues.push({
+                    file,
+                    check: 'raw-color-value',
+                    message: 'Raw color value found. Use CSS custom properties (var(--...)) for design token consistency.',
+                    severity: 'error',
+                });
+            }
         }
         // Check for non-tokenized custom properties
         if (tokenPrefix) {
@@ -156,9 +193,10 @@ export async function lintNewFileHeaders(repoDir, newFiles, config) {
  * @param affectedFiles - File paths (relative to repoDir)
  * @param newFiles - Set of files that are newly created in this patch
  * @param config - Project configuration
+ * @param patchOwnedFiles - Optional set of patch-owned `.sys.mjs` paths for scoped JSDoc enforcement
  * @returns Array of lint issues
  */
-export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config) {
+export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, patchOwnedFiles) {
     const jsFiles = affectedFiles.filter(isJsFile);
     if (jsFiles.length === 0)
         return [];
@@ -186,45 +224,50 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config) {
         // 2. File size check (new files only)
         if (isNew) {
             const lineCount = content.split('\n').length;
-            if (lineCount > 650) {
+            const isTest = isTestFile(file);
+            const thresholds = isTest ? FILE_SIZE_THRESHOLDS.test : FILE_SIZE_THRESHOLDS.general;
+            const label = isTest ? 'Test file' : 'New file';
+            const verb = isTest ? 'splitting' : 'decomposing';
+            if (lineCount >= thresholds.error) {
                 issues.push({
                     file,
                     check: 'file-too-large',
-                    message: `New file has ${lineCount} lines (recommended max: 650). Consider decomposing.`,
+                    message: `${label} has ${lineCount} lines (hard limit: ${thresholds.error}). Consider ${verb}.`,
+                    severity: 'error',
+                });
+            }
+            else if (lineCount >= thresholds.warning) {
+                issues.push({
+                    file,
+                    check: 'file-too-large',
+                    message: `${label} has ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider ${verb}.`,
                     severity: 'warning',
                 });
             }
+            else if (lineCount >= thresholds.notice) {
+                issues.push({
+                    file,
+                    check: 'file-too-large',
+                    message: `${label} has ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider ${verb}.`,
+                    severity: 'notice',
+                });
+            }
         }
-        // 3. JSDoc on exports (new .sys.mjs files only)
-        if (isNew && isSysMjs) {
-            const lines = content.split('\n');
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i] ?? '';
-                if (/^export\s+(function|class|const|let|var)\s/.test(line)) {
-                    // Walk backwards to find JSDoc
-                    let hasJsDoc = false;
-                    for (let j = i - 1; j >= 0; j--) {
-                        const prev = (lines[j] ?? '').trim();
-                        if (prev === '')
-                            continue;
-                        if (prev.endsWith('*/')) {
-                            hasJsDoc = true;
-                        }
-                        break;
-                    }
-                    if (!hasJsDoc) {
-                        issues.push({
-                            file,
-                            check: 'missing-jsdoc',
-                            message: `Export at line ${i + 1} is missing a JSDoc comment with @param/@returns.`,
-                            severity: 'warning',
-                        });
-                    }
-                }
+        // 3. JSDoc on exports (patch-owned .sys.mjs files)
+        const isOwned = patchOwnedFiles ? patchOwnedFiles.has(file) : isNew;
+        if (isOwned && isSysMjs) {
+            const jsdocIssues = validateExportJsDoc(content);
+            for (const jsdocIssue of jsdocIssues) {
+                issues.push({
+                    file,
+                    check: jsdocIssue.check,
+                    message: jsdocIssue.message,
+                    severity: 'error',
+                });
             }
         }
         // 4. Observer topic naming
-        const topicPattern = /(?:addObserver|removeObserver|notifyObservers)\s*\([^)]*["']([^"']+)["']/g;
+        const topicPattern = /(?:addObserver|removeObserver|notifyObservers)\s*\([^)\n]*["']([^"']+)["']/g;
         let topicMatch;
         while ((topicMatch = topicPattern.exec(strippedContent)) !== null) {
             const topic = topicMatch[1];
@@ -291,14 +334,32 @@ export function lintPatchSize(filesAffected, lineCount) {
             severity: 'warning',
         });
     }
-    if (lineCount > 300) {
+    const allTests = filesAffected.length > 0 && filesAffected.every(isTestFile);
+    const thresholds = allTests ? PATCH_LINE_THRESHOLDS.test : PATCH_LINE_THRESHOLDS.general;
+    if (lineCount >= thresholds.error) {
+        issues.push({
+            file: '(patch)',
+            check: 'large-patch-lines',
+            message: `Patch is ${lineCount} lines (hard limit: ${thresholds.error}). Consider splitting into smaller, focused patches.`,
+            severity: 'error',
+        });
+    }
+    else if (lineCount >= thresholds.warning) {
         issues.push({
             file: '(patch)',
             check: 'large-patch-lines',
-            message: `Patch is ${lineCount} lines (recommended: ≤300). Consider splitting into smaller, focused patches.`,
+            message: `Patch is ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider splitting into smaller, focused patches.`,
             severity: 'warning',
         });
     }
+    else if (lineCount >= thresholds.notice) {
+        issues.push({
+            file: '(patch)',
+            check: 'large-patch-lines',
+            message: `Patch is ${lineCount} lines (soft limit: ${thresholds.warning}, hard limit: ${thresholds.error}). Consider splitting into smaller, focused patches.`,
+            severity: 'notice',
+        });
+    }
     return issues;
 }
 // ---------------------------------------------------------------------------
@@ -346,20 +407,22 @@ export async function lintModifiedFileHeaders(repoDir, affectedFiles, newFiles)
  * @param affectedFiles - File paths (relative to repoDir) affected by the patch
  * @param diffContent - Raw unified diff string
  * @param config - Project configuration
+ * @param patchQueueCtx - Optional cross-patch context for ownership resolution
  * @returns Array of all lint issues found
  */
-export async function lintExportedPatch(repoDir, affectedFiles, diffContent, config) {
+export async function lintExportedPatch(repoDir, affectedFiles, diffContent, config, patchQueueCtx) {
     const newFiles = detectNewFilesInDiff(diffContent);
     const lineCount = diffContent.split('\n').length;
+    const patchOwnedFiles = resolvePatchOwnedSysMjs(newFiles, patchQueueCtx);
     const [cssIssues, headerIssues, jsIssues, modifiedHeaderIssues] = await Promise.all([
-        lintPatchedCss(repoDir, affectedFiles, diffContent),
+        lintPatchedCss(repoDir, affectedFiles, diffContent, config),
         lintNewFileHeaders(repoDir, [...newFiles], config),
-        lintPatchedJs(repoDir, affectedFiles, newFiles, config),
+        lintPatchedJs(repoDir, affectedFiles, newFiles, config, patchOwnedFiles),
         lintModifiedFileHeaders(repoDir, affectedFiles, newFiles),
     ]);
     const modCommentIssues = lintModificationComments(diffContent, config);
     const sizeIssues = lintPatchSize(affectedFiles, lineCount);
-    return [
+    const issues = [
         ...sizeIssues,
         ...cssIssues,
         ...headerIssues,
@@ -367,5 +430,11 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
         ...jsIssues,
         ...modCommentIssues,
     ];
+    // Optional checkJs pass — only when explicitly enabled in config
+    if (config.patchLint?.checkJs) {
+        const checkJsIssues = await runCheckJs(repoDir, patchOwnedFiles);
+        issues.push(...checkJsIssues);
+    }
+    return issues;
 }
 //# sourceMappingURL=patch-lint.js.map

package/dist/src/core/patch-manifest-resolve.d.ts

@@ -0,0 +1,5 @@
+import type { PatchMetadata } from '../types/commands/index.js';
+/**
+ * Resolves a patch identifier (ordinal number or filename) to its manifest entry.
+ */
+export declare function resolvePatchIdentifier(identifier: string, patches: PatchMetadata[]): PatchMetadata | null;

package/dist/src/core/patch-manifest-resolve.js

@@ -0,0 +1,12 @@
+/**
+ * Resolves a patch identifier (ordinal number or filename) to its manifest entry.
+ */
+export function resolvePatchIdentifier(identifier, patches) {
+    if (/^\d+$/.test(identifier)) {
+        const order = parseInt(identifier, 10);
+        return patches.find((p) => p.order === order) ?? null;
+    }
+    const normalized = identifier.endsWith('.patch') ? identifier : `${identifier}.patch`;
+    return patches.find((p) => p.filename === normalized) ?? null;
+}
+//# sourceMappingURL=patch-manifest-resolve.js.map

package/dist/src/core/patch-manifest.d.ts

@@ -8,4 +8,5 @@ export type { PatchManifestConsistencyIssue } from './patch-manifest-consistency
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
 export { addPatchToManifest, loadPatchesManifest, PatchDeleteRollbackError, PATCHES_MANIFEST, type PatchRenameEntry, removePatchFileAndManifest, removePatchFromManifest, renumberPatchesInManifest, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
+export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';