@ox0/guards 0.1.0

package/dist/index.js

@@ -0,0 +1,1023 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_oxc_parser_1c05de9b__ from "oxc-parser";
+function isNode(value) {
+    return Boolean(value) && "object" == typeof value && "string" == typeof value.type;
+}
+function walkChild(child, visitor, parent) {
+    if (Array.isArray(child)) {
+        for (const entry of child)walk(entry, visitor, parent);
+        return;
+    }
+    walk(child, visitor, parent);
+}
+function walk(node, visitor, parent = null) {
+    if (!isNode(node)) return;
+    visitor(node, parent);
+    for (const [key, value] of Object.entries(node))if ("parent" !== key) walkChild(value, visitor, node);
+}
+function getIdentifierName(node) {
+    if (!isNode(node)) return null;
+    if ("Identifier" === node.type || "JSXIdentifier" === node.type) return "string" == typeof node.name ? node.name : null;
+    return null;
+}
+function getCalleeName(node) {
+    if (!isNode(node)) return null;
+    if ("Identifier" === node.type) return "string" == typeof node.name ? node.name : null;
+    if ("MemberExpression" === node.type) {
+        const objectName = getCalleeName(node.object);
+        const propertyName = getIdentifierName(node.property);
+        return objectName && propertyName ? `${objectName}.${propertyName}` : null;
+    }
+    return null;
+}
+function getJsxElementName(node) {
+    if (!isNode(node)) return null;
+    if ("JSXIdentifier" === node.type) return "string" == typeof node.name ? node.name : null;
+    if ("JSXMemberExpression" === node.type) {
+        const objectName = getJsxElementName(node.object);
+        const propertyName = getJsxElementName(node.property);
+        return objectName && propertyName ? `${objectName}.${propertyName}` : null;
+    }
+    return null;
+}
+function getStringLiteralValue(node) {
+    if (!isNode(node)) return null;
+    if ("Literal" === node.type && "string" == typeof node.value) return node.value;
+    if ("TemplateLiteral" === node.type && Array.isArray(node.expressions) && 0 === node.expressions.length) {
+        const quasis = Array.isArray(node.quasis) ? node.quasis : [];
+        return quasis.map((quasi)=>{
+            if (!isNode(quasi)) return "";
+            const value = quasi.value;
+            if (!value || "object" != typeof value || "string" != typeof value.cooked) return "";
+            return value.cooked;
+        }).join("");
+    }
+    return null;
+}
+function isFunctionLike(node) {
+    return isNode(node) && ("FunctionDeclaration" === node.type || "FunctionExpression" === node.type || "ArrowFunctionExpression" === node.type);
+}
+function getFunctionName(node, parent) {
+    if (!isNode(node)) return null;
+    if ("id" in node && isNode(node.id) && "string" == typeof node.id.name) return node.id.name;
+    if (isNode(parent) && "VariableDeclarator" === parent.type && isNode(parent.id) && "Identifier" === parent.id.type && "string" == typeof parent.id.name) return parent.id.name;
+    return null;
+}
+const GUARD_HELPERS = {
+    walk,
+    getCalleeName,
+    getJsxElementName,
+    getStringLiteralValue,
+    isFunctionLike,
+    getFunctionName
+};
+const LABELABLE_ELEMENTS = new Set([
+    "input",
+    "select",
+    "textarea"
+]);
+const LABEL_ATTRIBUTES = new Set([
+    "aria-label",
+    "aria-labelledby"
+]);
+const ALLOWED_COMPONENT_PATHS = new Set([
+    "packages/ui/src/components/text-field.tsx"
+]);
+function hasUsefulAttribute(node, helpers) {
+    const attributes = Array.isArray(node.attributes) ? node.attributes : [];
+    for (const attribute of attributes){
+        if (!attribute || "object" != typeof attribute) continue;
+        const name = helpers.getJsxElementName(attribute.name);
+        if (name && LABEL_ATTRIBUTES.has(name)) return true;
+    }
+    return false;
+}
+const createMissingLabelGuard = ()=>[
+        "guard/missing-label",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("<input") || source.includes("<select") || source.includes("<textarea");
+            },
+            evaluate ({ helpers, program, relativeFilePath }) {
+                if (ALLOWED_COMPONENT_PATHS.has(relativeFilePath.split("\\").join("/"))) return [];
+                const findings = [];
+                helpers.walk(program, (node, parent)=>{
+                    if ("JSXElement" !== node.type) return;
+                    const openingElement = node.openingElement;
+                    if (!openingElement) return;
+                    const elementName = helpers.getJsxElementName(openingElement.name);
+                    if (!elementName || !LABELABLE_ELEMENTS.has(elementName)) return;
+                    if (hasUsefulAttribute(openingElement, helpers)) return;
+                    const wrappedByLabel = parent?.type === "JSXElement" && "label" === helpers.getJsxElementName(parent.openingElement.name);
+                    if (wrappedByLabel) return;
+                    findings.push({
+                        start: openingElement.start,
+                        end: openingElement.end,
+                        message: "Form controls must have a visible label or an accessible label via aria-label or aria-labelledby."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+function isPascalCase(name) {
+    return Boolean(name) && /^[A-Z]/.test(name ?? "");
+}
+const createNoAsyncReactComponentGuard = ()=>[
+        "guard/no-async-react-component",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("async");
+            },
+            evaluate ({ helpers, program }) {
+                const findings = [];
+                helpers.walk(program, (node, parent)=>{
+                    if (!helpers.isFunctionLike(node)) return;
+                    if (true !== node.async) return;
+                    const name = helpers.getFunctionName(node, parent);
+                    if (!isPascalCase(name)) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: "React components should not be async. Move async work into loaders, actions, or effects."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const INTL_CONSTRUCTORS = new Set([
+    "Intl.DateTimeFormat",
+    "Intl.NumberFormat",
+    "Intl.RelativeTimeFormat",
+    "Intl.PluralRules",
+    "Intl.Collator",
+    "Intl.ListFormat",
+    "Intl.Segmenter"
+]);
+const ALLOWED_PATHS = [
+    "packages/i18n/"
+];
+function isAllowedPath(relativeFilePath) {
+    const normalized = relativeFilePath.split("\\").join("/");
+    return ALLOWED_PATHS.some((prefix)=>normalized.startsWith(prefix));
+}
+const createNoBareIntlGuard = ()=>[
+        "guard/no-bare-intl",
+        {
+            fileExtensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".mjs",
+                ".cjs",
+                ".mts",
+                ".cts"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("new Intl.");
+            },
+            evaluate ({ helpers, program, relativeFilePath }) {
+                if (isAllowedPath(relativeFilePath)) return [];
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if ("NewExpression" !== node.type) return;
+                    const calleeName = helpers.getCalleeName(node.callee);
+                    if (!calleeName || !INTL_CONSTRUCTORS.has(calleeName)) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: `Do not construct bare ${calleeName} instances. Intl constructors are slow; use the caching helpers from the i18n package instead.`
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const CSS_PATTERN = /\.(css|scss|less)$/i;
+const ALLOWED_SPECIFIERS = new Set([
+    "@ox0/tokens/styles.css"
+]);
+const ALLOWED_FILE_PATHS = new Set([
+    "packages/ui/src/providers/ox0-provider.tsx"
+]);
+function isAllowedImport(relativeFilePath, sourceValue) {
+    const normalizedPath = relativeFilePath.split("\\").join("/");
+    return Boolean(sourceValue) && ALLOWED_SPECIFIERS.has(sourceValue ?? "") && ALLOWED_FILE_PATHS.has(normalizedPath);
+}
+function isCssSpecifier(value) {
+    return Boolean(value && CSS_PATTERN.test(value));
+}
+const createNoCssImportGuard = ()=>[
+        "guard/no-css-import",
+        {
+            fileExtensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".mjs",
+                ".cjs",
+                ".mts",
+                ".cts"
+            ],
+            tokenPrefilter (source) {
+                return source.includes(".css") || source.includes(".scss") || source.includes(".less");
+            },
+            evaluate ({ helpers, program, relativeFilePath }) {
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if ("ImportDeclaration" === node.type || "ExportAllDeclaration" === node.type) {
+                        const sourceValue = helpers.getStringLiteralValue(node.source);
+                        if (isAllowedImport(relativeFilePath, sourceValue) || !isCssSpecifier(sourceValue)) return;
+                        findings.push({
+                            start: node.start,
+                            end: node.end,
+                            message: "CSS imports are not allowed here. Route shared styling through approved package entrypoints."
+                        });
+                        return;
+                    }
+                    if ("ExportNamedDeclaration" === node.type && node.source) {
+                        const sourceValue = helpers.getStringLiteralValue(node.source);
+                        if (isAllowedImport(relativeFilePath, sourceValue) || !isCssSpecifier(sourceValue)) return;
+                        findings.push({
+                            start: node.start,
+                            end: node.end,
+                            message: "CSS re-exports are not allowed here. Route shared styling through approved package entrypoints."
+                        });
+                        return;
+                    }
+                    if ("CallExpression" === node.type) {
+                        const calleeName = helpers.getCalleeName(node.callee);
+                        if ("require" !== calleeName) return;
+                        const [firstArg] = Array.isArray(node.arguments) ? node.arguments : [];
+                        const sourceValue = helpers.getStringLiteralValue(firstArg);
+                        if (isAllowedImport(relativeFilePath, sourceValue) || !isCssSpecifier(sourceValue)) return;
+                        findings.push({
+                            start: node.start,
+                            end: node.end,
+                            message: "CSS require calls are not allowed here. Route shared styling through approved package entrypoints."
+                        });
+                        return;
+                    }
+                    if ("ImportExpression" !== node.type) return;
+                    const sourceValue = helpers.getStringLiteralValue(node.source);
+                    if (isAllowedImport(relativeFilePath, sourceValue) || !isCssSpecifier(sourceValue)) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: "Dynamic CSS imports are not allowed here. Route shared styling through approved package entrypoints."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const EFFECT_HOOKS = new Set([
+    "useEffect",
+    "useLayoutEffect"
+]);
+function no_effect_set_state_chain_isNode(value) {
+    return Boolean(value) && "object" == typeof value && !Array.isArray(value);
+}
+function isIdentifier(node) {
+    return no_effect_set_state_chain_isNode(node) && "Identifier" === node.type && "string" == typeof node.name;
+}
+function getFunctionBody(node) {
+    return no_effect_set_state_chain_isNode(node) && no_effect_set_state_chain_isNode(node.body) ? node.body : null;
+}
+function collectStatePairs(body) {
+    const setterToState = new Map();
+    const statements = Array.isArray(body.body) ? body.body : [];
+    for (const statement of statements){
+        if (!no_effect_set_state_chain_isNode(statement) || "VariableDeclaration" !== statement.type) continue;
+        const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+        for (const declaration of declarations){
+            if (!no_effect_set_state_chain_isNode(declaration)) continue;
+            const id = declaration.id;
+            const init = declaration.init;
+            if (!no_effect_set_state_chain_isNode(id) || !no_effect_set_state_chain_isNode(init) || "CallExpression" !== init.type) continue;
+            const callee = init.callee;
+            if (!isIdentifier(callee) || "useState" !== callee.name) continue;
+            const elements = Array.isArray(id.elements) ? id.elements : [];
+            const [stateNode, setterNode] = elements;
+            if (!!isIdentifier(stateNode) && !!isIdentifier(setterNode)) setterToState.set(setterNode.name, stateNode.name);
+        }
+    }
+    return setterToState;
+}
+function collectDependencyNames(node) {
+    const names = new Set();
+    const elements = Array.isArray(node.elements) ? node.elements : [];
+    for (const element of elements)if (isIdentifier(element)) names.add(element.name);
+    return names;
+}
+function referencesIdentifier(node, identifierName, helpers) {
+    let found = false;
+    helpers.walk(node, (current)=>{
+        if (found) return;
+        if ("Identifier" === current.type && current.name === identifierName) found = true;
+    });
+    return found;
+}
+const createNoEffectSetStateChainGuard = ()=>[
+        "guard/no-effect-set-state-chain",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx"
+            ],
+            tokenPrefilter (source) {
+                return (source.includes("useEffect") || source.includes("useLayoutEffect")) && source.includes("useState") && source.includes("set");
+            },
+            evaluate ({ helpers, program }) {
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if (!helpers.isFunctionLike(node)) return;
+                    const functionBody = getFunctionBody(node);
+                    if (!functionBody || "BlockStatement" !== functionBody.type) return;
+                    const setterToState = collectStatePairs(functionBody);
+                    if (0 === setterToState.size) return;
+                    helpers.walk(functionBody, (innerNode)=>{
+                        if ("CallExpression" !== innerNode.type) return;
+                        const hookName = helpers.getCalleeName(innerNode.callee);
+                        if (!hookName || !EFFECT_HOOKS.has(hookName)) return;
+                        const args = Array.isArray(innerNode.arguments) ? innerNode.arguments : [];
+                        const callback = args[0];
+                        const deps = args[1];
+                        if (!callback || !helpers.isFunctionLike(callback) || !no_effect_set_state_chain_isNode(deps) || "ArrayExpression" !== deps.type) return;
+                        const depNames = collectDependencyNames(deps);
+                        if (0 === depNames.size) return;
+                        const callbackBody = getFunctionBody(callback);
+                        if (!callbackBody) return;
+                        helpers.walk(callbackBody, (effectNode)=>{
+                            if ("CallExpression" !== effectNode.type) return;
+                            const callee = effectNode.callee;
+                            if (!isIdentifier(callee)) return;
+                            const stateName = setterToState.get(callee.name);
+                            if (!stateName || !depNames.has(stateName)) return;
+                            const [firstArgument] = Array.isArray(effectNode.arguments) ? effectNode.arguments : [];
+                            if (!firstArgument || !referencesIdentifier(firstArgument, stateName, helpers)) return;
+                            findings.push({
+                                start: effectNode.start,
+                                end: effectNode.end,
+                                message: `Avoid deriving state in effects via ${callee.name} from the dependency state "${stateName}".`
+                            });
+                        });
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+function no_set_state_in_render_isPascalCase(name) {
+    return Boolean(name) && /^[A-Z]/.test(name ?? "");
+}
+function isStateSetterName(name) {
+    return Boolean(name) && /^set[A-Z0-9]/.test(name ?? "");
+}
+function scanRenderBody(node, findings) {
+    const body = Array.isArray(node.body) ? node.body : [];
+    for (const statement of body){
+        if (!statement || "object" != typeof statement) continue;
+        const current = statement;
+        if ("FunctionDeclaration" === current.type || "FunctionExpression" === current.type || "ArrowFunctionExpression" === current.type) continue;
+        if ("ExpressionStatement" === current.type) {
+            const expression = current.expression;
+            if (expression?.type === "CallExpression") {
+                const callee = expression.callee;
+                if (callee?.type === "Identifier" && isStateSetterName(callee.name)) findings.push({
+                    start: expression.start,
+                    end: expression.end,
+                    message: "Do not call state setters during render. Derive values in render or move the write to an event or effect."
+                });
+            }
+        }
+        const consequent = current.consequent;
+        if (consequent && Array.isArray(consequent.body)) scanRenderBody(consequent, findings);
+        const alternate = current.alternate;
+        if (alternate && Array.isArray(alternate.body)) scanRenderBody(alternate, findings);
+        if (Array.isArray(current.body)) scanRenderBody(current, findings);
+    }
+}
+const createNoSetStateInRenderGuard = ()=>[
+        "guard/no-set-state-in-render",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("set");
+            },
+            evaluate ({ helpers, program }) {
+                const findings = [];
+                helpers.walk(program, (node, parent)=>{
+                    if (!helpers.isFunctionLike(node)) return;
+                    const name = helpers.getFunctionName(node, parent);
+                    if (!no_set_state_in_render_isPascalCase(name)) return;
+                    const body = node.body;
+                    if (!body || "BlockStatement" !== body.type) return;
+                    scanRenderBody(body, findings);
+                });
+                return findings;
+            }
+        }
+    ];
+const EXCLUDED_PATHS = new Set([
+    "packages/guards/",
+    "packages/hooks/src/use-local-storage.ts",
+    "packages/utils/src/index.ts",
+    "scripts/"
+]);
+function isExcludedPath(relativeFilePath) {
+    const normalized = relativeFilePath.split("\\").join("/");
+    return [
+        ...EXCLUDED_PATHS
+    ].some((entry)=>normalized === entry || normalized.startsWith(entry));
+}
+const createNoUnsafeTypeAssertionGuard = ()=>[
+        "guard/no-unsafe-type-assertion",
+        {
+            fileExtensions: [
+                ".ts",
+                ".tsx",
+                ".mts",
+                ".cts"
+            ],
+            tokenPrefilter (source) {
+                return source.includes(" as ");
+            },
+            evaluate ({ helpers, program, relativeFilePath, source }) {
+                if (relativeFilePath.endsWith(".d.ts") || isExcludedPath(relativeFilePath)) return [];
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if ("TSAsExpression" !== node.type) return;
+                    const expressionText = source.slice(node.start, node.end);
+                    if (expressionText.trimEnd().endsWith(" as const")) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: "Unsafe type assertions are not allowed here. Prefer narrowing, validation, or better typing."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const STORAGE_NAMES = new Set([
+    "localStorage",
+    "sessionStorage",
+    "window.localStorage",
+    "window.sessionStorage",
+    "globalThis.localStorage",
+    "globalThis.sessionStorage"
+]);
+const ALLOWED_WRAPPER_PATHS = new Set([
+    "packages/hooks/src/use-local-storage.ts"
+]);
+const createNoWebStorageGuard = ()=>[
+        "guard/no-web-storage",
+        {
+            fileExtensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx",
+                ".mjs",
+                ".cjs",
+                ".mts",
+                ".cts"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("localStorage") || source.includes("sessionStorage");
+            },
+            evaluate ({ filePath, helpers, program }) {
+                const normalizedFilePath = filePath.split("\\").join("/");
+                if ([
+                    ...ALLOWED_WRAPPER_PATHS
+                ].some((allowedPath)=>normalizedFilePath.endsWith(allowedPath))) return [];
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if ("Identifier" !== node.type && "MemberExpression" !== node.type) return;
+                    const name = "Identifier" === node.type ? helpers.getCalleeName(node) : helpers.getCalleeName(node.object);
+                    if (!name || !STORAGE_NAMES.has(name)) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: "Direct web storage access is not allowed in ox0 primitives. Use a storage abstraction or inject persistence."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const require_effect_cleanup_EFFECT_HOOKS = new Set([
+    "useEffect",
+    "useLayoutEffect"
+]);
+const OBSERVER_NAMES = new Set([
+    "MutationObserver",
+    "ResizeObserver"
+]);
+function require_effect_cleanup_getFunctionBody(node) {
+    const body = node.body;
+    return body && "object" == typeof body && !Array.isArray(body) ? body : null;
+}
+function getReturnCleanupFunction(node) {
+    const body = require_effect_cleanup_getFunctionBody(node);
+    if (!body || "BlockStatement" !== body.type) return null;
+    const statements = Array.isArray(body.body) ? body.body : [];
+    for (const statement of statements){
+        if (!statement || "object" != typeof statement) continue;
+        const current = statement;
+        if ("ReturnStatement" !== current.type) continue;
+        const argument = current.argument;
+        if (!!argument && "object" == typeof argument) {
+            if ("FunctionExpression" === argument.type || "ArrowFunctionExpression" === argument.type) return argument;
+        }
+    }
+    return null;
+}
+function collectSetups(body, helpers) {
+    const setups = [];
+    helpers.walk(body, (node)=>{
+        if ("CallExpression" === node.type) {
+            const calleeName = helpers.getCalleeName(node.callee);
+            if ("setInterval" === calleeName || "window.setInterval" === calleeName) setups.push({
+                kind: "interval",
+                start: node.start,
+                end: node.end
+            });
+            if ("setTimeout" === calleeName || "window.setTimeout" === calleeName) setups.push({
+                kind: "timeout",
+                start: node.start,
+                end: node.end
+            });
+            if (calleeName?.endsWith(".addEventListener") || "addEventListener" === calleeName) setups.push({
+                kind: "event-listener",
+                start: node.start,
+                end: node.end
+            });
+            return;
+        }
+        if ("NewExpression" !== node.type) return;
+        const calleeName = helpers.getCalleeName(node.callee);
+        if (!calleeName || !OBSERVER_NAMES.has(calleeName)) return;
+        setups.push({
+            kind: "observer",
+            start: node.start,
+            end: node.end
+        });
+    });
+    return setups;
+}
+function collectCleanupKinds(cleanupFn, helpers) {
+    const kinds = new Set();
+    const body = require_effect_cleanup_getFunctionBody(cleanupFn);
+    if (!body) return kinds;
+    helpers.walk(body, (node)=>{
+        if ("CallExpression" !== node.type) return;
+        const calleeName = helpers.getCalleeName(node.callee);
+        if ("clearInterval" === calleeName || "window.clearInterval" === calleeName) {
+            kinds.add("interval");
+            return;
+        }
+        if ("clearTimeout" === calleeName || "window.clearTimeout" === calleeName) {
+            kinds.add("timeout");
+            return;
+        }
+        if (calleeName?.endsWith(".removeEventListener") || "removeEventListener" === calleeName) {
+            kinds.add("event-listener");
+            return;
+        }
+        if (calleeName?.endsWith(".disconnect") || "disconnect" === calleeName) kinds.add("observer");
+    });
+    return kinds;
+}
+function getSetupLabel(kind) {
+    if ("event-listener" === kind) return "event listeners";
+    if ("observer" === kind) return "observers";
+    if ("timeout" === kind) return "timeouts";
+    return "intervals";
+}
+const createRequireEffectCleanupGuard = ()=>[
+        "guard/require-effect-cleanup",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx",
+                ".ts",
+                ".js",
+                ".mts",
+                ".cts",
+                ".mjs",
+                ".cjs"
+            ],
+            tokenPrefilter (source) {
+                return (source.includes("useEffect") || source.includes("useLayoutEffect")) && (source.includes("addEventListener") || source.includes("setInterval") || source.includes("setTimeout") || source.includes("MutationObserver") || source.includes("ResizeObserver"));
+            },
+            evaluate ({ helpers, program }) {
+                const findings = [];
+                helpers.walk(program, (node)=>{
+                    if ("CallExpression" !== node.type) return;
+                    const hookName = helpers.getCalleeName(node.callee);
+                    if (!hookName || !require_effect_cleanup_EFFECT_HOOKS.has(hookName)) return;
+                    const [callback] = Array.isArray(node.arguments) ? node.arguments : [];
+                    if (!callback || "object" != typeof callback || !helpers.isFunctionLike(callback)) return;
+                    const callbackBody = require_effect_cleanup_getFunctionBody(callback);
+                    if (!callbackBody) return;
+                    const setups = collectSetups(callbackBody, helpers);
+                    if (0 === setups.length) return;
+                    const cleanupFn = getReturnCleanupFunction(callback);
+                    const cleanupKinds = cleanupFn ? collectCleanupKinds(cleanupFn, helpers) : new Set();
+                    for (const setup of setups)if (!cleanupKinds.has(setup.kind)) findings.push({
+                        start: setup.start,
+                        end: setup.end,
+                        message: `Effects that create ${getSetupLabel(setup.kind)} must return a matching cleanup.`
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+function isInlineUnstableExpression(node) {
+    return "ObjectExpression" === node.type || "ArrayExpression" === node.type || "ArrowFunctionExpression" === node.type || "FunctionExpression" === node.type || "NewExpression" === node.type;
+}
+const createStableProviderValuesGuard = ()=>[
+        "guard/stable-provider-values",
+        {
+            fileExtensions: [
+                ".jsx",
+                ".tsx"
+            ],
+            tokenPrefilter (source) {
+                return source.includes("Provider") && source.includes("value=");
+            },
+            evaluate ({ helpers, program }) {
+                const findings = [];
+                helpers.walk(program, (node, parent)=>{
+                    if ("JSXAttribute" !== node.type) return;
+                    const attributeName = helpers.getJsxElementName(node.name);
+                    if ("value" !== attributeName) return;
+                    if (!parent || "JSXOpeningElement" !== parent.type || !helpers.getJsxElementName(parent.name)?.endsWith("Provider")) return;
+                    const valueNode = node.value;
+                    if (!valueNode || "JSXExpressionContainer" !== valueNode.type) return;
+                    const expression = valueNode.expression;
+                    if (!expression || "object" != typeof expression) return;
+                    if (!isInlineUnstableExpression(expression)) return;
+                    findings.push({
+                        start: node.start,
+                        end: node.end,
+                        message: "Provider values should be referentially stable. Hoist or memoize the value before passing it to a Provider."
+                    });
+                });
+                return findings;
+            }
+        }
+    ];
+const GUARD_FACTORIES = [
+    createNoAsyncReactComponentGuard,
+    createNoBareIntlGuard,
+    createNoCssImportGuard,
+    createNoEffectSetStateChainGuard,
+    createNoSetStateInRenderGuard,
+    createNoUnsafeTypeAssertionGuard,
+    createStableProviderValuesGuard,
+    createNoWebStorageGuard,
+    createMissingLabelGuard,
+    createRequireEffectCleanupGuard
+];
+const INTERNAL_INVALID_DISABLE_RULE = "guard/invalid-disable-comment";
+const INTERNAL_PARSE_ERROR_RULE = "guard/parse-error";
+const SCRIPT_EXTENSIONS = new Set([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts"
+]);
+const EXCLUDED_DIRECTORIES = new Set([
+    ".git",
+    ".idea",
+    ".next",
+    ".rspress",
+    ".turbo",
+    "coverage",
+    "dist",
+    "doc_build",
+    "node_modules"
+]);
+function isScriptFile(filePath) {
+    return SCRIPT_EXTENSIONS.has(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(filePath));
+}
+function shouldExcludeDirectory(relativeDirPath) {
+    return relativeDirPath.split(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].sep).some((segment)=>segment.length > 0 && EXCLUDED_DIRECTORIES.has(segment));
+}
+function collectProjectFiles(projectRoot, allowedExtensions) {
+    const files = [];
+    function walkDirectory(currentDir) {
+        const entries = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readdirSync(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const fullPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(currentDir, entry.name);
+            const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(projectRoot, fullPath);
+            if (entry.isDirectory()) {
+                if (shouldExcludeDirectory(relativePath)) continue;
+                walkDirectory(fullPath);
+                continue;
+            }
+            if (allowedExtensions.has(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(entry.name))) files.push(fullPath);
+        }
+    }
+    walkDirectory(projectRoot);
+    return files.toSorted();
+}
+function createLineStarts(source) {
+    const starts = [
+        0
+    ];
+    for(let index = 0; index < source.length; index += 1)if ("\n" === source[index]) starts.push(index + 1);
+    return starts;
+}
+function getLocationFromOffset(lineStarts, offset) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while(low <= high){
+        const mid = Math.floor((low + high) / 2);
+        const start = lineStarts[mid];
+        const nextStart = lineStarts[mid + 1] ?? Number.POSITIVE_INFINITY;
+        if (offset < start) high = mid - 1;
+        else {
+            if (!(offset >= nextStart)) return {
+                line: mid + 1,
+                column: offset - lineStarts[mid] + 1
+            };
+            low = mid + 1;
+        }
+    }
+    return {
+        line: 1,
+        column: 1
+    };
+}
+function buildFinding(ruleId, rawFinding, filePath, relativeFilePath, lineStarts) {
+    const startLocation = getLocationFromOffset(lineStarts, rawFinding.start);
+    const endLocation = getLocationFromOffset(lineStarts, rawFinding.end ?? rawFinding.start);
+    return {
+        ruleId,
+        message: rawFinding.message,
+        filePath,
+        relativeFilePath,
+        line: startLocation.line,
+        column: startLocation.column,
+        endLine: endLocation.line,
+        endColumn: endLocation.column,
+        severity: "error"
+    };
+}
+function parseDisableDirective(line, lineNumber) {
+    const match = line.match(/^\s*\/\/\s*guard-disable-(next-line|start|end)\s+(\S+)(?:\s+(.*\S))?\s*$/);
+    if (!match) return null;
+    return {
+        type: match[1],
+        ruleId: match[2],
+        rationale: match[3] ?? "",
+        line: lineNumber,
+        column: line.indexOf("//") + 1
+    };
+}
+function parseSuppressions(source, knownRuleIds) {
+    const suppressions = [];
+    const invalid = [];
+    const openBlocks = new Map();
+    const lines = source.split(/\r?\n/);
+    for(let index = 0; index < lines.length; index += 1){
+        const lineNumber = index + 1;
+        const directive = parseDisableDirective(lines[index], lineNumber);
+        if (!directive) continue;
+        if (!knownRuleIds.has(directive.ruleId)) {
+            invalid.push({
+                line: directive.line,
+                column: directive.column,
+                message: `Disable comment references unknown rule "${directive.ruleId}".`
+            });
+            continue;
+        }
+        if (("next-line" === directive.type || "start" === directive.type) && "" === directive.rationale.trim()) {
+            invalid.push({
+                line: directive.line,
+                column: directive.column,
+                message: `Disable comment for ${directive.ruleId} must include a rationale.`
+            });
+            continue;
+        }
+        if ("next-line" === directive.type) {
+            suppressions.push({
+                ruleId: directive.ruleId,
+                startLine: directive.line + 1,
+                endLine: directive.line + 1
+            });
+            continue;
+        }
+        if ("start" === directive.type) {
+            openBlocks.set(directive.ruleId, directive);
+            continue;
+        }
+        const startDirective = openBlocks.get(directive.ruleId);
+        if (!startDirective) {
+            invalid.push({
+                line: directive.line,
+                column: directive.column,
+                message: `guard-disable-end for ${directive.ruleId} has no matching start.`
+            });
+            continue;
+        }
+        suppressions.push({
+            ruleId: directive.ruleId,
+            startLine: startDirective.line + 1,
+            endLine: Math.max(startDirective.line + 1, directive.line - 1)
+        });
+        openBlocks.delete(directive.ruleId);
+    }
+    for (const directive of openBlocks.values())invalid.push({
+        line: directive.line,
+        column: directive.column,
+        message: `guard-disable-start for ${directive.ruleId} is missing a matching end.`
+    });
+    return {
+        suppressions,
+        invalid
+    };
+}
+function isSuppressed(finding, suppressions) {
+    return suppressions.some((suppression)=>suppression.ruleId === finding.ruleId && finding.line >= suppression.startLine && finding.line <= suppression.endLine);
+}
+function sortFindings(findings) {
+    const sortedFindings = findings.toSorted((left, right)=>{
+        if (left.relativeFilePath !== right.relativeFilePath) return left.relativeFilePath.localeCompare(right.relativeFilePath);
+        if (left.line !== right.line) return left.line - right.line;
+        if (left.column !== right.column) return left.column - right.column;
+        return left.ruleId.localeCompare(right.ruleId);
+    });
+    findings.splice(0, findings.length, ...sortedFindings);
+}
+function getRuleRegistry() {
+    const registry = new Map();
+    for (const factory of GUARD_FACTORIES){
+        const [ruleId, definition] = factory();
+        registry.set(ruleId, definition);
+    }
+    return registry;
+}
+function listGuardRuleIds() {
+    return [
+        ...getRuleRegistry().keys()
+    ].toSorted();
+}
+function runGuards(options) {
+    const projectRoot = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(options.cwd ?? process.cwd(), options.projectRoot);
+    const registry = getRuleRegistry();
+    const knownRuleIds = new Set([
+        ...registry.keys(),
+        INTERNAL_INVALID_DISABLE_RULE,
+        INTERNAL_PARSE_ERROR_RULE
+    ]);
+    const requestedRuleIds = options.requestedRules?.length ? options.requestedRules.map((ruleId)=>ruleId) : [
+        ...registry.keys()
+    ];
+    for (const ruleId of requestedRuleIds)if (!registry.has(ruleId)) throw new Error(`Unknown guard rule: ${ruleId}`);
+    const selectedEntries = [
+        ...registry.entries()
+    ].filter(([ruleId])=>requestedRuleIds.includes(ruleId));
+    const allowedExtensions = new Set();
+    for (const [, definition] of selectedEntries)for (const extension of definition.fileExtensions)allowedExtensions.add(extension);
+    const files = collectProjectFiles(projectRoot, allowedExtensions);
+    const findings = [];
+    for (const filePath of files){
+        const relativeFilePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(projectRoot, filePath);
+        const source = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(filePath, "utf8");
+        const lineStarts = createLineStarts(source);
+        const { suppressions, invalid } = parseSuppressions(source, knownRuleIds);
+        for (const invalidFinding of invalid)findings.push({
+            ruleId: INTERNAL_INVALID_DISABLE_RULE,
+            message: invalidFinding.message,
+            filePath,
+            relativeFilePath,
+            line: invalidFinding.line,
+            column: invalidFinding.column,
+            endLine: invalidFinding.line,
+            endColumn: invalidFinding.column,
+            severity: "error"
+        });
+        const extension = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(filePath);
+        const applicableRules = selectedEntries.filter(([, definition])=>definition.fileExtensions.includes(extension) && definition.tokenPrefilter(source));
+        if (0 === applicableRules.length) continue;
+        for (const [ruleId, definition] of applicableRules.filter(([, candidate])=>"function" == typeof candidate.evaluateText)){
+            const rawFindings = definition.evaluateText?.({
+                ruleId,
+                projectRoot,
+                filePath,
+                relativeFilePath,
+                source
+            }) ?? [];
+            for (const rawFinding of rawFindings){
+                const finding = buildFinding(ruleId, rawFinding, filePath, relativeFilePath, lineStarts);
+                if (!isSuppressed(finding, suppressions)) findings.push(finding);
+            }
+        }
+        const astRules = applicableRules.filter(([, definition])=>"function" == typeof definition.evaluate && isScriptFile(filePath));
+        if (0 === astRules.length) continue;
+        const parseResult = (0, __WEBPACK_EXTERNAL_MODULE_oxc_parser_1c05de9b__.parseSync)(relativeFilePath, source, {
+            astType: "ts"
+        });
+        if (Array.isArray(parseResult.errors) && parseResult.errors.length > 0) {
+            for (const error of parseResult.errors){
+                const start = "start" in error && "number" == typeof error.start ? error.start : 0;
+                findings.push(buildFinding(INTERNAL_PARSE_ERROR_RULE, {
+                    start,
+                    end: start,
+                    message: `Parse error: ${String(error.message ?? "unknown parser error")}`
+                }, filePath, relativeFilePath, lineStarts));
+            }
+            continue;
+        }
+        for (const [ruleId, definition] of astRules){
+            const rawFindings = definition.evaluate?.({
+                ruleId,
+                projectRoot,
+                filePath,
+                relativeFilePath,
+                source,
+                helpers: GUARD_HELPERS,
+                program: parseResult.program,
+                comments: parseResult.comments ?? []
+            }) ?? [];
+            for (const rawFinding of rawFindings){
+                const finding = buildFinding(ruleId, rawFinding, filePath, relativeFilePath, lineStarts);
+                if (!isSuppressed(finding, suppressions)) findings.push(finding);
+            }
+        }
+    }
+    sortFindings(findings);
+    return {
+        findings,
+        ruleIds: listGuardRuleIds()
+    };
+}
+function defineGuardsConfig(config) {
+    return config;
+}
+const recommendedRules = [
+    {
+        id: "guard/no-async-react-component",
+        severity: "error"
+    },
+    {
+        id: "guard/no-css-import",
+        severity: "error"
+    },
+    {
+        id: "guard/no-effect-set-state-chain",
+        severity: "error"
+    },
+    {
+        id: "guard/no-set-state-in-render",
+        severity: "error"
+    },
+    {
+        id: "guard/no-unsafe-type-assertion",
+        severity: "error"
+    },
+    {
+        id: "guard/stable-provider-values",
+        severity: "error"
+    },
+    {
+        id: "guard/no-web-storage",
+        severity: "error"
+    },
+    {
+        id: "guard/missing-label",
+        severity: "error"
+    },
+    {
+        id: "guard/require-effect-cleanup",
+        severity: "error"
+    }
+];
+export { GUARD_FACTORIES, defineGuardsConfig, listGuardRuleIds, recommendedRules, runGuards };