@webpresso/agent-config 0.4.2 → 0.4.4

package/dist/esm/oxlint/import-hygiene.js

@@ -0,0 +1,220 @@
+// @ts-nocheck
+// Webpresso import hygiene rules — replaces GritQL patterns:
+// - no-relative-parent-imports
+// - no-src-path-imports
+// - no-relative-mock-paths
+// - no-forbidden-package-imports
+import { isAgentKitSeaTreeFile, isPlatformAppFile, isSdkPackageFile, normalizeFilename, } from "./path-roles.js";
+export { isAgentKitSeaTreeFile, isPlatformAppFile, isSdkPackageFile, normalizeFilename, } from "./path-roles.js";
+const CROSS_PACKAGE_SEGMENT = /(?:^|\/)(packages|apps|tooling|infra|webpresso)\//;
+function isRelativeParentPath(source) {
+    return typeof source === "string" && source.includes("../");
+}
+function isRelativeGeneratedImport(source) {
+    return (typeof source === "string" && source.startsWith(".") && source.includes(".webpresso/generated/"));
+}
+function isGeneratedPathsSourceImport(source) {
+    return (typeof source === "string" && source.includes("/packages/cli/cli-utils/src/generated-paths"));
+}
+function isAllowedRelativeParentImport(source) {
+    return isGeneratedPathsSourceImport(source);
+}
+function isCrossPackageRelativePath(source) {
+    return isRelativeParentPath(source) && CROSS_PACKAGE_SEGMENT.test(source);
+}
+function reportRelativeParentImport(context, node) {
+    context.report({
+        node,
+        message: "Use `#` or package imports instead of relative parent imports. For cross-package access, add a proper package export and import via the package name.",
+    });
+}
+function reportCrossPackageImport(context, node) {
+    context.report({
+        node,
+        message: "Do not reach into another package/app with a relative filesystem import. Add a proper package export and import it via the package name.",
+    });
+}
+function getFilename(context) {
+    if (typeof context.getFilename === "function") {
+        return normalizeFilename(context.getFilename());
+    }
+    return normalizeFilename(context.filename);
+}
+function checkStaticModuleSource(node, callback) {
+    if (!node.source)
+        return;
+    callback(node.source.value, node.source);
+}
+/** Package imports forbidden in agent-kit SEA surfaces (schema + ui paint kits). */
+export function isSeaForbiddenPackageImport(source) {
+    if (typeof source !== "string")
+        return false;
+    return (source === "@webpresso/schema" ||
+        source.startsWith("@webpresso/schema/") ||
+        source === "@webpresso/ui" ||
+        source.startsWith("@webpresso/ui/"));
+}
+export const SEA_FORBIDDEN_IMPORT_MESSAGE = "Agent-kit SEA surfaces (compose / wp_ui_*) must not import `@webpresso/schema` or `@webpresso/ui`. Use the two-tier block registry snapshot/project file and local Zod/HTML paint instead (offline / nondeterminism lock).";
+function isSchemaEngineImport(source) {
+    return typeof source === "string" && source.startsWith("@webpresso/schema/engine/");
+}
+function isSchemaRuntimeImport(source) {
+    return typeof source === "string" && source.startsWith("@webpresso/schema-runtime");
+}
+function isGeneratedImport(source) {
+    return typeof source === "string" && source.startsWith("@webpresso/generated/");
+}
+const FORBIDDEN_SDK_TOOLING_IMPORTS = new Set([
+    "@webpresso/schema/loaders",
+    "@webpresso/cli-utils",
+    "@webpresso/blueprint",
+]);
+const noRelativeParentImports = {
+    create(context) {
+        function checkSource(source, node) {
+            if (isRelativeGeneratedImport(source)) {
+                context.report({
+                    node,
+                    message: "Do not import generated artifacts via relative filesystem paths. Use the real workspace package `@webpresso/generated/*` instead.",
+                });
+                return;
+            }
+            if (isRelativeParentPath(source) && !isAllowedRelativeParentImport(source)) {
+                reportRelativeParentImport(context, node);
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkSource(node.source.value, node.source);
+            },
+            // Also catch export ... from '../...'
+            ExportNamedDeclaration(node) {
+                checkStaticModuleSource(node, checkSource);
+            },
+            ExportAllDeclaration(node) {
+                checkStaticModuleSource(node, checkSource);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== "Literal")
+                    return;
+                const source = node.source.value;
+                if (isCrossPackageRelativePath(source)) {
+                    reportCrossPackageImport(context, node.source);
+                }
+            },
+        };
+    },
+};
+const noSrcPathImports = {
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (typeof source === "string" && source.includes("../src/")) {
+                    context.report({
+                        node: node.source,
+                        message: "Use `#` alias instead of `../src/` paths (e.g. '#database' not '../src/database').",
+                    });
+                }
+            },
+        };
+    },
+};
+const noRelativeMockPaths = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" ||
+                    node.callee.object.type !== "Identifier" ||
+                    node.callee.object.name !== "vi" ||
+                    node.callee.property.type !== "Identifier" ||
+                    node.callee.property.name !== "mock") {
+                    return;
+                }
+                const arg = node.arguments[0];
+                if (!arg || arg.type !== "Literal" || typeof arg.value !== "string")
+                    return;
+                if (arg.value.includes("../")) {
+                    context.report({
+                        node: arg,
+                        message: "Ban vi.mock() with relative parent paths. Use the module's package name or `#` alias instead.",
+                    });
+                }
+            },
+        };
+    },
+};
+const noForbiddenPackageImports = {
+    create(context) {
+        const filename = getFilename(context);
+        function checkImport(source, node) {
+            if (typeof source !== "string")
+                return;
+            // Agent-kit SEA / offline compose — ban before monorepo platform allow rules.
+            // Consumers still get this rule via shipped oxlintrc; monorepo apps do not match
+            // isAgentKitSeaTreeFile so public schema imports remain allowed there.
+            if (isAgentKitSeaTreeFile(filename) && isSeaForbiddenPackageImport(source)) {
+                context.report({
+                    node,
+                    message: SEA_FORBIDDEN_IMPORT_MESSAGE,
+                });
+                return;
+            }
+            if (isPlatformAppFile(filename) &&
+                isSchemaEngineImport(source) &&
+                source !== "@webpresso/schema/engine/api") {
+                context.report({
+                    node,
+                    message: "Platform apps may only import `@webpresso/schema/engine/api`, `@webpresso/generated/*`, or `@webpresso/schema-runtime/*`. Move schema-engine internals behind a public surface.",
+                });
+                return;
+            }
+            if (isPlatformAppFile(filename) && isGeneratedImport(source)) {
+                return;
+            }
+            if (isSdkPackageFile(filename) && FORBIDDEN_SDK_TOOLING_IMPORTS.has(source)) {
+                context.report({
+                    node,
+                    message: "SDK packages must not import CLI/tooling packages such as `@webpresso/schema/loaders`, `@webpresso/cli-utils`, or `@webpresso/blueprint`.",
+                });
+                return;
+            }
+            // Runtime helpers are allowed for platform apps, so keep the explicit allowlist
+            // visible here rather than indirectly relying on a broader schema-engine prefix.
+            if (isPlatformAppFile(filename) &&
+                isSchemaRuntimeImport(source) &&
+                !source.startsWith("@webpresso/schema-runtime/")) {
+                context.report({
+                    node,
+                    message: "Platform apps must import `@webpresso/schema-runtime/*` subpaths, not the package root.",
+                });
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkImport(node.source.value, node.source);
+            },
+            ExportNamedDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ExportAllDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== "Literal")
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: "webpresso-imports" },
+    rules: {
+        "no-relative-parent-imports": noRelativeParentImports,
+        "no-src-path-imports": noSrcPathImports,
+        "no-relative-mock-paths": noRelativeMockPaths,
+        "no-forbidden-package-imports": noForbiddenPackageImports,
+    },
+};
+export default plugin;

package/dist/esm/oxlint/index.d.ts

@@ -0,0 +1,23 @@
+import codeSafety from "./code-safety.js";
+import foundationPurity from "./foundation-purity.js";
+import graphqlConventions from "./graphql-conventions.js";
+import importHygiene from "./import-hygiene.js";
+import monorepoNpaths from "./monorepo-paths.js";
+import queryPatterns from "./query-patterns.js";
+import testingQuality from "./testing-quality.js";
+import tierBoundaries from "./tier-boundaries.js";
+export { OXLINT_PACKAGE_SUBPATH_BASENAMES, OXLINT_PATH_ROLES_BASENAME, OXLINT_POLICY_PLUGIN_BASENAMES, agentConfigOxlintPluginSpecifier, agentConfigOxlintPluginSpecifiers, type OxlintPackageSubpathBasename, type OxlintPathRolesBasename, type OxlintPolicyPluginBasename, } from "./basenames.js";
+type OxlintRuleSeverity = "error";
+interface OxlintPlugin {
+    meta: {
+        name: string;
+    };
+    rules: Record<string, unknown>;
+}
+export { codeSafety, foundationPurity, graphqlConventions, importHygiene, monorepoNpaths, queryPatterns, testingQuality, tierBoundaries, };
+export declare const plugins: Record<string, OxlintPlugin>;
+export declare const rules: Record<string, OxlintRuleSeverity>;
+export declare const config: {
+    plugins: Record<string, OxlintPlugin>;
+    rules: Record<string, "error">;
+};

package/dist/esm/oxlint/index.js

@@ -0,0 +1,29 @@
+import codeSafety from "./code-safety.js";
+import foundationPurity from "./foundation-purity.js";
+import graphqlConventions from "./graphql-conventions.js";
+import importHygiene from "./import-hygiene.js";
+import monorepoNpaths from "./monorepo-paths.js";
+import queryPatterns from "./query-patterns.js";
+import testingQuality from "./testing-quality.js";
+import tierBoundaries from "./tier-boundaries.js";
+export { OXLINT_PACKAGE_SUBPATH_BASENAMES, OXLINT_PATH_ROLES_BASENAME, OXLINT_POLICY_PLUGIN_BASENAMES, agentConfigOxlintPluginSpecifier, agentConfigOxlintPluginSpecifiers, } from "./basenames.js";
+export { codeSafety, foundationPurity, graphqlConventions, importHygiene, monorepoNpaths, queryPatterns, testingQuality, tierBoundaries, };
+const pluginEntries = [
+    codeSafety,
+    foundationPurity,
+    graphqlConventions,
+    importHygiene,
+    monorepoNpaths,
+    queryPatterns,
+    testingQuality,
+    tierBoundaries,
+].map((plugin) => [plugin.meta.name, plugin]);
+export const plugins = Object.fromEntries(pluginEntries);
+export const rules = Object.fromEntries(pluginEntries.flatMap(([pluginName, plugin]) => Object.keys(plugin.rules).map((ruleName) => [
+    `${pluginName}/${ruleName}`,
+    "error",
+])));
+export const config = {
+    plugins,
+    rules,
+};

package/dist/esm/oxlint/monorepo-paths.d.ts

@@ -0,0 +1,22 @@
+export declare function hardcodedRepoRootDepth(args: any): {
+    depth: number;
+    index: number;
+} | null;
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-hardcoded-repo-root": {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        "no-cross-package-paths": {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;

package/dist/esm/oxlint/monorepo-paths.js

@@ -0,0 +1,135 @@
+// @ts-nocheck
+// Webpresso monorepo path rules — replaces GritQL patterns:
+// - no-hardcoded-repo-root (import.meta.dirname + '../..')
+// - no-hardcoded-repo-root-dirname (__dirname + '../..')
+// - no-cross-package-paths (single-arg)
+// - no-cross-package-paths-multiarg
+const RESOLVE_FUNCTIONS = new Set(["resolve", "join"]);
+const QUALIFIED_RESOLVE = new Set(["path.resolve", "path.join"]);
+function getCalleeName(callee) {
+    if (callee.type === "Identifier")
+        return callee.name;
+    if (callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier" &&
+        callee.property.type === "Identifier") {
+        return `${callee.object.name}.${callee.property.name}`;
+    }
+    return null;
+}
+function isMetaDirname(node) {
+    return (node.type === "MemberExpression" &&
+        node.object.type === "MetaProperty" &&
+        node.property.type === "Identifier" &&
+        node.property.name === "dirname");
+}
+function isDunderDirname(node) {
+    return node.type === "Identifier" && node.name === "__dirname";
+}
+// Count parent-directory ('..') segments in a single path-literal value.
+// Handles a combined literal ('../..' → 2) and both path separators.
+function countParentSegments(value) {
+    if (typeof value !== "string")
+        return 0;
+    return value.split(/[/\\]/u).filter((segment) => segment === "..").length;
+}
+// Total '..' traversal depth across the resolve/join arguments after the
+// anchor. Returns { depth, index } pointing at the first traversal argument
+// when depth >= 2 (the repo-root-climb threshold), else null.
+//
+// Unifying the single-literal ('../..') and multi-argument ('..', '..') forms
+// into one depth count closes a gap: the previous matcher only caught the
+// multi-argument form at 4+ arguments, so `join(import.meta.dirname, '..',
+// '..')` (two separate '..' args, depth 2) silently passed.
+export function hardcodedRepoRootDepth(args) {
+    let depth = 0;
+    let index = -1;
+    for (let i = 1; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg.type !== "Literal")
+            continue;
+        const segments = countParentSegments(arg.value);
+        if (segments > 0 && index === -1)
+            index = i;
+        depth += segments;
+    }
+    return depth >= 2 && index !== -1 ? { depth, index } : null;
+}
+const noHardcodedRepoRoot = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const name = getCalleeName(node.callee);
+                if (!name)
+                    return;
+                if (!RESOLVE_FUNCTIONS.has(name) && !QUALIFIED_RESOLVE.has(name))
+                    return;
+                const args = node.arguments;
+                if (args.length < 2)
+                    return;
+                const violation = hardcodedRepoRootDepth(args);
+                if (!violation)
+                    return;
+                const first = args[0];
+                const source = isMetaDirname(first)
+                    ? "import.meta.dirname"
+                    : isDunderDirname(first)
+                        ? "__dirname"
+                        : "variable";
+                context.report({
+                    node: args[violation.index],
+                    message: `Hardcoded repo root via ${source} + '..' traversal (depth ${violation.depth}). Derive the repo root dynamically — search upward for a workspace marker such as pnpm-workspace.yaml (e.g. findRepoRoot) — instead of hardcoding the directory depth.`,
+                });
+            },
+        };
+    },
+};
+const MONOREPO_DIRS = /(?:packages|apps|tooling|infra)/;
+const noCrossPackagePaths = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const name = getCalleeName(node.callee);
+                if (!name)
+                    return;
+                if (!RESOLVE_FUNCTIONS.has(name) && !QUALIFIED_RESOLVE.has(name))
+                    return;
+                const args = node.arguments;
+                if (args.length < 2)
+                    return;
+                const first = args[0];
+                if (!isDunderDirname(first) && !isMetaDirname(first))
+                    return;
+                // Single-arg: resolve(__dirname, '../../../packages/foo')
+                for (let i = 1; i < args.length; i++) {
+                    const arg = args[i];
+                    if (arg.type !== "Literal" || typeof arg.value !== "string")
+                        continue;
+                    if (/\.\./.test(arg.value) && MONOREPO_DIRS.test(arg.value)) {
+                        context.report({
+                            node: arg,
+                            message: "Cross-package path traversal via __dirname. Use proper package imports or findRepoRoot() instead.",
+                        });
+                        return;
+                    }
+                }
+                // Multi-arg: resolve(__dirname, '..', '..', 'packages', 'cli2')
+                const hasParent = args.some((a) => a.type === "Literal" && a.value === "..");
+                const hasMonoDir = args.some((a) => a.type === "Literal" && typeof a.value === "string" && MONOREPO_DIRS.test(a.value));
+                if (hasParent && hasMonoDir) {
+                    context.report({
+                        node: args[1],
+                        message: "Cross-package path traversal via __dirname. Use proper package imports or findRepoRoot() instead.",
+                    });
+                }
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: "webpresso-monorepo" },
+    rules: {
+        "no-hardcoded-repo-root": noHardcodedRepoRoot,
+        "no-cross-package-paths": noCrossPackagePaths,
+    },
+};
+export default plugin;

package/dist/esm/oxlint/path-roles.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared path classifiers for webpresso oxlint policy plugins.
+ * Pure functions only — no AST. Consumers resolve plugins from
+ * `@webpresso/agent-config/oxlint/*`; these markers must match real trees.
+ */
+/** Normalize Windows paths for substring role checks. */
+export declare function normalizeFilename(filename: any): string;
+/**
+ * Offline / SEA-shaped agent-kit surfaces (compose + UI MCP tools).
+ * Monorepo apps never use these path segments.
+ */
+export declare function isAgentKitSeaTreeFile(filename: any): boolean;
+/** Platform web apps: real monorepo layout + legacy `/apps/web/`. */
+export declare function isPlatformWebFile(filename: any): boolean;
+/** Platform workers: real monorepo layout + legacy `/apps/workers/`. */
+export declare function isPlatformWorkerFile(filename: any): boolean;
+/** Platform apps (web or worker) for import-hygiene schema-surface rules. */
+export declare function isPlatformAppFile(filename: any): boolean;
+/**
+ * Client UI surfaces for GraphQL/query-pattern rules.
+ * Real monorepo: apps/platform/web/.../app/; legacy apps/web/.../app/.
+ */
+export declare function isWebAppSurface(filename: any): boolean;
+export declare function isSdkPackageFile(filename: any): boolean;

package/dist/esm/oxlint/path-roles.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+/**
+ * Shared path classifiers for webpresso oxlint policy plugins.
+ * Pure functions only — no AST. Consumers resolve plugins from
+ * `@webpresso/agent-config/oxlint/*`; these markers must match real trees.
+ */
+/** Normalize Windows paths for substring role checks. */
+export function normalizeFilename(filename) {
+    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
+}
+/**
+ * Offline / SEA-shaped agent-kit surfaces (compose + UI MCP tools).
+ * Monorepo apps never use these path segments.
+ */
+export function isAgentKitSeaTreeFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/src/compose/") || n.includes("/src/mcp/tools/wp-ui-");
+}
+/** Platform web apps: real monorepo layout + legacy `/apps/web/`. */
+export function isPlatformWebFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/apps/platform/web/") || n.includes("/apps/web/");
+}
+/** Platform workers: real monorepo layout + legacy `/apps/workers/`. */
+export function isPlatformWorkerFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/apps/platform/workers/") || n.includes("/apps/workers/");
+}
+/** Platform apps (web or worker) for import-hygiene schema-surface rules. */
+export function isPlatformAppFile(filename) {
+    return isPlatformWebFile(filename) || isPlatformWorkerFile(filename);
+}
+/**
+ * Client UI surfaces for GraphQL/query-pattern rules.
+ * Real monorepo: apps/platform/web/.../app/; legacy apps/web/.../app/.
+ */
+export function isWebAppSurface(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    if (!n.includes("/app/"))
+        return false;
+    return n.includes("/apps/platform/web/") || n.includes("/apps/web/");
+}
+export function isSdkPackageFile(filename) {
+    return normalizeFilename(filename).includes("/packages/sdk/");
+}

package/dist/esm/oxlint/query-patterns.d.ts

@@ -0,0 +1,24 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-adhoc-useQuery": {
+            create(context: any): {
+                CallExpression?: undefined;
+            } | {
+                CallExpression(node: any): void;
+            };
+        };
+        "no-isLoading-on-queries": {
+            create(context: any): {
+                VariableDeclarator?: undefined;
+                MemberExpression?: undefined;
+            } | {
+                VariableDeclarator(node: any): void;
+                MemberExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;

package/dist/esm/oxlint/query-patterns.js

@@ -0,0 +1,122 @@
+// @ts-nocheck
+import { isWebAppSurface, normalizeFilename } from "./path-roles.js";
+const QUERY_HOOK_NAMES = new Set(["useQuery", "useSuspenseQuery", "useInfiniteQuery"]);
+function getFilename(context) {
+    if (typeof context.getFilename === "function") {
+        return normalizeFilename(context.getFilename());
+    }
+    return normalizeFilename(context.filename);
+}
+function isClientQuerySurface(filename) {
+    const normalized = normalizeFilename(filename);
+    if (!/\.tsx?$/.test(normalized))
+        return false;
+    if (normalized.includes("/.webpresso/generated/"))
+        return false;
+    const isFeatureSurface = normalized.includes("/packages/feature/") && normalized.includes("/src/");
+    return isWebAppSurface(normalized) || isFeatureSurface;
+}
+function getCalleeName(callee) {
+    if (!callee)
+        return null;
+    if (callee.type === "Identifier")
+        return callee.name;
+    if (callee.type === "MemberExpression" &&
+        !callee.computed &&
+        callee.property?.type === "Identifier") {
+        return callee.property.name;
+    }
+    return null;
+}
+function isQueryHookCall(node) {
+    return node?.type === "CallExpression" && QUERY_HOOK_NAMES.has(getCalleeName(node.callee));
+}
+function isTrackedQueryResult(init, queryResultBindings) {
+    return init?.type === "Identifier" && queryResultBindings.has(init.name);
+}
+function isIsLoadingProperty(property) {
+    return ((property?.type === "Identifier" && property.name === "isLoading") ||
+        (property?.type === "Literal" && property.value === "isLoading"));
+}
+function reportAdhocQuery(context, node) {
+    context.report({
+        node,
+        message: "TanStack Query hard cut: pass a named query options identifier to useQuery/useSuspenseQuery/useInfiniteQuery instead of an inline object literal.",
+    });
+}
+function reportIsLoading(context, node) {
+    context.report({
+        node,
+        message: "TanStack Query hard cut: use isPending (or domain-specific derived state) instead of isLoading on query results.",
+    });
+}
+const noAdhocUseQuery = {
+    create(context) {
+        if (!isClientQuerySurface(getFilename(context))) {
+            return {};
+        }
+        return {
+            CallExpression(node) {
+                if (!isQueryHookCall(node))
+                    return;
+                const firstArgument = node.arguments[0];
+                if (firstArgument?.type !== "ObjectExpression")
+                    return;
+                reportAdhocQuery(context, firstArgument);
+            },
+        };
+    },
+};
+const noIsLoadingOnQueries = {
+    create(context) {
+        if (!isClientQuerySurface(getFilename(context))) {
+            return {};
+        }
+        const queryResultBindings = new Set();
+        function trackQueryResultBinding(id, init) {
+            if (id?.type !== "Identifier")
+                return;
+            if (!isQueryHookCall(init))
+                return;
+            queryResultBindings.add(id.name);
+        }
+        function reportObjectPattern(node) {
+            for (const property of node.properties ?? []) {
+                if (property?.type !== "Property")
+                    continue;
+                if (!isIsLoadingProperty(property.key))
+                    continue;
+                reportIsLoading(context, property.key);
+            }
+        }
+        return {
+            VariableDeclarator(node) {
+                trackQueryResultBinding(node.id, node.init);
+                if (node.id?.type !== "ObjectPattern")
+                    return;
+                if (!isQueryHookCall(node.init) && !isTrackedQueryResult(node.init, queryResultBindings))
+                    return;
+                reportObjectPattern(node.id);
+            },
+            MemberExpression(node) {
+                if (node.computed)
+                    return;
+                if (!isIsLoadingProperty(node.property))
+                    return;
+                if (node.object?.type !== "Identifier")
+                    return;
+                if (!queryResultBindings.has(node.object.name))
+                    return;
+                reportIsLoading(context, node.property);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: "webpresso-query-patterns" },
+    rules: {
+        "no-adhoc-useQuery": noAdhocUseQuery,
+        "no-isLoading-on-queries": noIsLoadingOnQueries,
+    },
+};
+export default plugin;