@hominis/fireforge 0.11.2 → 0.12.0

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

@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Optional TypeScript `checkJs` pass for patch-owned `.sys.mjs` files.
+ *
+ * Loads the TypeScript compiler API via dynamic import so it is only
+ * required when `patchLint.checkJs` is enabled in `fireforge.json`.
+ * TypeScript remains a dev-dependency — if a user enables checkJs
+ * without installing it, the pass emits a clear error explaining
+ * how to fix it.
+ *
+ * Separated from `patch-lint.ts` to keep both files within the
+ * project's per-file line budget.
+ */
+import { resolve } from 'node:path';
+import { pathExists } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+// ---------------------------------------------------------------------------
+// Firefox globals shim
+// ---------------------------------------------------------------------------
+const SHIM_FILENAME = '__fireforge_firefox_globals.d.ts';
+/**
+ * Minimal `.d.ts` shim for Firefox privileged-scope globals.
+ *
+ * Firefox source is plain JS — no TypeScript allowed. The shim lets
+ * `checkJs` run without reporting "cannot find name" for the most
+ * common Mozilla APIs. Types are intentionally loose (`any`) because
+ * full Firefox type coverage is out of scope.
+ *
+ * Notable patterns that require shimming:
+ * - `const lazy = {};` + `ChromeUtils.defineESModuleGetters(lazy, { ... })`
+ *   populates `lazy` at runtime; we declare it as `Record<string, any>`.
+ * - `Services.obs`, `Services.prefs`, etc. are XPCOM service accessors.
+ * - `Ci`, `Cc`, `Cr`, `Cu` are XPCOM component shortcuts.
+ * - Browser chrome globals like `gBrowser`, `gURLBar` are common in
+ *   content scripts wired via `browser.js`.
+ */
+const FIREFOX_GLOBALS_SHIM = `
+declare var Services: any;
+declare var ChromeUtils: {
+  defineESModuleGetters(target: any, modules: Record<string, string>): void;
+  importESModule(specifier: string): any;
+  import(specifier: string): any;
+  defineModuleGetter(target: any, name: string, specifier: string): void;
+  generateQI(interfaces: any[]): Function;
+  isClassInfo(obj: any): boolean;
+};
+declare var Cu: any;
+declare var Ci: any;
+declare var Cc: any;
+declare var Cr: any;
+declare var Components: any;
+declare var XPCOMUtils: any;
+declare var lazy: Record<string, any>;
+declare var PathUtils: any;
+declare var IOUtils: any;
+declare var FileUtils: any;
+declare var gBrowser: any;
+declare var gURLBar: any;
+declare var gNavigatorBundle: any;
+declare var AppConstants: any;
+`;
+// ---------------------------------------------------------------------------
+// Diagnostic filtering
+// ---------------------------------------------------------------------------
+/**
+ * TS diagnostic codes to suppress because they are inherent to
+ * checking Firefox JS files outside of Mozilla's own build system.
+ *
+ * Firefox uses `resource://` and `chrome://` URL schemes for module
+ * imports. TypeScript's module resolver cannot follow these, so every
+ * import from an upstream Firefox module produces a spurious
+ * "Cannot find module" error. Filtering these out is essential to
+ * keep the checkJs pass usable — otherwise every file with an import
+ * would be buried in false positives.
+ */
+const SUPPRESSED_DIAGNOSTIC_CODES = new Set([
+    2307, // Cannot find module '{0}' or its corresponding type declarations.
+    2306, // File '{0}' is not a module.
+    2305, // Module '{0}' has no exported member '{1}'.
+    2792, // Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option...
+    2304, // Cannot find name '{0}'. (for globals we missed in the shim)
+    2552, // Cannot find name '{0}'. Did you mean '{1}'?
+    2580, // Cannot find name '{0}'. Do you need to install type definitions...
+    7016, // Could not find a declaration file for module '{0}'.
+]);
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Runs TypeScript's checkJs pass on patch-owned `.sys.mjs` files.
+ *
+ * @param repoDir - Absolute path to the engine (repository) directory
+ * @param patchOwnedFiles - Set of patch-owned `.sys.mjs` file paths (relative to repoDir)
+ * @returns Array of lint issues from TS diagnostics
+ */
+export async function runCheckJs(repoDir, patchOwnedFiles) {
+    if (patchOwnedFiles.size === 0)
+        return [];
+    // Dynamic import — typescript stays as a dev dependency
+    let ts;
+    try {
+        ts = await import('typescript');
+    }
+    catch {
+        return [
+            {
+                file: '(checkJs)',
+                check: 'checkjs-type-error',
+                message: 'patchLint.checkJs is enabled but the "typescript" package is not installed. ' +
+                    'Run "npm install typescript" to enable type checking.',
+                severity: 'error',
+            },
+        ];
+    }
+    // Resolve absolute paths for root files, filtering to files that exist
+    const rootFiles = [];
+    const ownedAbsolute = new Set();
+    for (const rel of patchOwnedFiles) {
+        const abs = resolve(repoDir, rel);
+        if (await pathExists(abs)) {
+            rootFiles.push(abs);
+            ownedAbsolute.add(abs);
+        }
+    }
+    if (rootFiles.length === 0)
+        return [];
+    const shimPath = resolve(repoDir, SHIM_FILENAME);
+    rootFiles.push(shimPath);
+    const options = {
+        allowJs: true,
+        checkJs: true,
+        noEmit: true,
+        strict: false,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        skipLibCheck: true,
+        // Do not follow import/reference directives into the Firefox tree.
+        // We only want to check the patch-owned files themselves.
+        // Without this, TS would try (and fail) to resolve every
+        // resource:// and chrome:// import, flooding the output with
+        // "Cannot find module" errors for upstream Firefox modules.
+        noResolve: true,
+        // Suppress implicit-any noise — Firefox code rarely has full type
+        // annotations and drowning users in thousands of implicit-any
+        // errors defeats the purpose of a focused check.
+        noImplicitAny: false,
+    };
+    // Custom compiler host: reads patch-owned files from disk, returns
+    // the shim for the shim path, and returns empty content for
+    // anything else to avoid reading the full Firefox tree.
+    const defaultHost = ts.createCompilerHost(options);
+    const host = {
+        ...defaultHost,
+        getSourceFile(fileName, languageVersion, onError) {
+            if (fileName === shimPath) {
+                return ts.createSourceFile(fileName, FIREFOX_GLOBALS_SHIM, languageVersion, true);
+            }
+            if (ownedAbsolute.has(fileName)) {
+                return defaultHost.getSourceFile(fileName, languageVersion, onError);
+            }
+            // For lib files (lib.es*.d.ts) delegate to the default host
+            // so built-in types like Promise, Array, etc. are available.
+            if (fileName.includes('lib.') && fileName.endsWith('.d.ts')) {
+                return defaultHost.getSourceFile(fileName, languageVersion, onError);
+            }
+            // Return an empty source file for anything else to avoid
+            // reading unrelated Firefox source files.
+            return ts.createSourceFile(fileName, '', languageVersion, true);
+        },
+        fileExists(fileName) {
+            if (fileName === shimPath)
+                return true;
+            if (ownedAbsolute.has(fileName))
+                return true;
+            return defaultHost.fileExists(fileName);
+        },
+        readFile(fileName) {
+            if (fileName === shimPath)
+                return FIREFOX_GLOBALS_SHIM;
+            return defaultHost.readFile(fileName);
+        },
+    };
+    const program = ts.createProgram(rootFiles, options, host);
+    const allDiagnostics = [
+        ...program.getSemanticDiagnostics(),
+        ...program.getSyntacticDiagnostics(),
+    ];
+    // Filter to diagnostics originating in patch-owned files only,
+    // and suppress module-resolution / unknown-name noise that is
+    // inherent to checking Firefox JS outside Mozilla's build system.
+    const issues = [];
+    for (const diag of allDiagnostics) {
+        if (SUPPRESSED_DIAGNOSTIC_CODES.has(diag.code))
+            continue;
+        const sourceFile = diag.file;
+        if (!sourceFile)
+            continue;
+        if (!ownedAbsolute.has(sourceFile.fileName))
+            continue;
+        const lineInfo = sourceFile.getLineAndCharacterOfPosition(diag.start ?? 0);
+        const line = lineInfo.line + 1;
+        const messageText = typeof diag.messageText === 'string'
+            ? diag.messageText
+            : ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+        // Find the relative path for the issue
+        let relPath = sourceFile.fileName;
+        for (const [rel, abs] of [...patchOwnedFiles].map((r) => [r, resolve(repoDir, r)])) {
+            if (abs === sourceFile.fileName) {
+                relPath = rel;
+                break;
+            }
+        }
+        const severity = diag.category === ts.DiagnosticCategory.Error ? 'error' : 'warning';
+        issues.push({
+            file: relPath,
+            check: 'checkjs-type-error',
+            message: `Line ${line}: ${messageText}`,
+            severity,
+        });
+    }
+    verbose(`checkJs: analyzed ${rootFiles.length - 1} file(s), found ${issues.length} issue(s)`);
+    return issues;
+}
+//# sourceMappingURL=patch-lint-checkjs.js.map

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

@@ -113,6 +113,7 @@ export declare function isForwardImportableFile(path: string): boolean;
  * - `import "specifier"`            (side-effect imports — the `from`
  *                                   clause is optional in the regex)
  * - `import("specifier")`           (dynamic imports)
+ * - ChromeUtils.importESModule("specifier")
  * - ChromeUtils.defineESModuleGetters(obj, { Name: "specifier", ... })
  *
  * Returns the raw specifier strings — callers should take the leaf basename

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

@@ -156,6 +156,7 @@ export function isForwardImportableFile(path) {
  * - `import "specifier"`            (side-effect imports — the `from`
  *                                   clause is optional in the regex)
  * - `import("specifier")`           (dynamic imports)
+ * - ChromeUtils.importESModule("specifier")
  * - ChromeUtils.defineESModuleGetters(obj, { Name: "specifier", ... })
  *
  * Returns the raw specifier strings — callers should take the leaf basename
@@ -282,6 +283,12 @@ export function extractImportSpecifiersWithLines(source) {
         if (match[1])
             results.push({ specifier: match[1], line: offsetToLine(match.index) });
     }
+    // ChromeUtils.importESModule("resource://...") — Firefox single-module import
+    const chromeUtilsPattern = /ChromeUtils\.importESModule\s*\(\s*["']([^"']+)["']/g;
+    while ((match = chromeUtilsPattern.exec(stripped)) !== null) {
+        if (match[1])
+            results.push({ specifier: match[1], line: offsetToLine(match.index) });
+    }
     collectGetterSpecifiers(stripped, results, offsetToLine);
     return results;
 }

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

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+export type JsDocCheck = 'missing-jsdoc' | 'jsdoc-param-mismatch' | 'jsdoc-missing-returns';
+export interface JsDocIssue {
+    line: number;
+    check: JsDocCheck;
+    message: string;
+}
+/**
+ * Validates JSDoc on exported declarations in a `.sys.mjs` source file.
+ *
+ * @param source - File content
+ * @returns Array of JSDoc issues found
+ */
+export declare function validateExportJsDoc(source: string): JsDocIssue[];

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,11 @@
 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';
 /**
  * Detects comment style from file extension for license header checks.
  */
@@ -34,9 +37,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 +71,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[]>;