@sanity/groq-lint 0.0.1 → 0.0.2

package/dist/cli.js

@@ -1,13 +1,1033 @@
 #!/usr/bin/env node
-import {
-  initLinter,
-  lint
-} from "./chunk-5C74HJYX.js";
 
 // src/cli.ts
 import { readFileSync, existsSync } from "fs";
 import { glob } from "fs/promises";
 import { createRequire } from "module";
+
+// src/linter.ts
+import { parse } from "groq-js";
+
+// src/walker.ts
+function walk(node, visitor, context = { inFilter: false, inProjection: false, parents: [] }) {
+  visitor(node, context);
+  const childContext = {
+    ...context,
+    parents: [...context.parents, node]
+  };
+  switch (node.type) {
+    case "Filter": {
+      walk(node.base, visitor, childContext);
+      walk(node.expr, visitor, { ...childContext, inFilter: true });
+      break;
+    }
+    case "Projection": {
+      walk(node.base, visitor, childContext);
+      walk(node.expr, visitor, { ...childContext, inProjection: true });
+      break;
+    }
+    case "And":
+    case "Or":
+    case "OpCall": {
+      walk(node.left, visitor, childContext);
+      walk(node.right, visitor, childContext);
+      break;
+    }
+    case "Not":
+    case "Neg":
+    case "Pos":
+    case "Asc":
+    case "Desc":
+    case "Group": {
+      walk(node.base, visitor, childContext);
+      break;
+    }
+    case "Deref": {
+      walk(node.base, visitor, childContext);
+      break;
+    }
+    case "AccessAttribute": {
+      if (node.base) {
+        walk(node.base, visitor, childContext);
+      }
+      break;
+    }
+    case "AccessElement": {
+      walk(node.base, visitor, childContext);
+      break;
+    }
+    case "Slice": {
+      walk(node.base, visitor, childContext);
+      break;
+    }
+    case "ArrayCoerce": {
+      walk(node.base, visitor, childContext);
+      break;
+    }
+    case "FlatMap":
+    case "Map": {
+      walk(node.base, visitor, childContext);
+      walk(node.expr, visitor, childContext);
+      break;
+    }
+    case "Array": {
+      for (const element of node.elements) {
+        walk(element.value, visitor, childContext);
+      }
+      break;
+    }
+    case "Object": {
+      for (const attr of node.attributes) {
+        if (attr.type === "ObjectAttributeValue") {
+          walk(attr.value, visitor, childContext);
+        } else if (attr.type === "ObjectConditionalSplat") {
+          walk(attr.condition, visitor, childContext);
+          walk(attr.value, visitor, childContext);
+        } else if (attr.type === "ObjectSplat") {
+          walk(attr.value, visitor, childContext);
+        }
+      }
+      break;
+    }
+    case "FuncCall": {
+      for (const arg of node.args) {
+        walk(arg, visitor, childContext);
+      }
+      break;
+    }
+    case "PipeFuncCall": {
+      walk(node.base, visitor, childContext);
+      for (const arg of node.args) {
+        walk(arg, visitor, childContext);
+      }
+      break;
+    }
+    case "Select": {
+      for (const alt of node.alternatives) {
+        walk(alt.condition, visitor, childContext);
+        walk(alt.value, visitor, childContext);
+      }
+      if (node.fallback) {
+        walk(node.fallback, visitor, childContext);
+      }
+      break;
+    }
+    case "InRange": {
+      walk(node.base, visitor, childContext);
+      walk(node.left, visitor, childContext);
+      walk(node.right, visitor, childContext);
+      break;
+    }
+    case "Tuple": {
+      for (const member of node.members) {
+        walk(member, visitor, childContext);
+      }
+      break;
+    }
+    // Leaf nodes - no children to walk
+    case "Everything":
+    case "This":
+    case "Parent":
+    case "Value":
+    case "Parameter":
+    case "Context":
+      break;
+    default: {
+      break;
+    }
+  }
+}
+
+// src/rules/computed-value-in-filter.ts
+var ARITHMETIC_OPS = ["+", "-", "*", "/"];
+function containsParentRef(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "Parent") {
+      found = true;
+    }
+  });
+  return found;
+}
+function isLiteral(node) {
+  if (node.type === "Value") return true;
+  if (node.type === "Parameter") return true;
+  if (node.type === "FuncCall" && node.name === "now") return true;
+  if (node.type === "OpCall") {
+    const op = node.op;
+    if (ARITHMETIC_OPS.includes(op ?? "")) {
+      const left = node.left;
+      const right = node.right;
+      if (left && right && isLiteral(left) && isLiteral(right)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isArithmeticOp(node) {
+  return node.type === "OpCall" && ARITHMETIC_OPS.includes(node.op ?? "");
+}
+var computedValueInFilter = {
+  id: "computed-value-in-filter",
+  name: "Computed Value in Filter",
+  description: "Avoid computed values in filters. Indices cannot be used.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node, walkContext) => {
+      if (!walkContext.inFilter) return;
+      if (isArithmeticOp(node)) {
+        if (containsParentRef(node.left) || containsParentRef(node.right)) {
+          return;
+        }
+        if (isLiteral(node.left) && isLiteral(node.right)) {
+          return;
+        }
+        context.report({
+          message: `Arithmetic operation '${node.op}' in filter prevents index usage.`,
+          severity: "warning",
+          help: "Consider pre-computing values or adding additional filters to reduce the search space."
+        });
+      }
+    });
+  }
+};
+
+// src/rules/count-in-correlated-subquery.ts
+function containsParentRef2(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "Parent") {
+      found = true;
+    }
+  });
+  return found;
+}
+var countInCorrelatedSubquery = {
+  id: "count-in-correlated-subquery",
+  name: "Count in Correlated Subquery",
+  description: "count() on correlated subquery can be slow.",
+  severity: "info",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "FuncCall") {
+        const name = node.name;
+        if (name !== "count") return;
+        const args = node.args ?? [];
+        if (args.length !== 1) return;
+        const arg = args[0];
+        if (!arg) return;
+        if (arg.type === "Filter") {
+          if (containsParentRef2(arg)) {
+            context.report({
+              message: "count() on correlated subquery does not execute as an efficient aggregation.",
+              severity: "info",
+              help: "This pattern may be slow on large datasets. Consider restructuring the query."
+            });
+          }
+        }
+      }
+    });
+  }
+};
+
+// src/rules/deep-pagination.ts
+var DEEP_PAGINATION_THRESHOLD = 1e3;
+var deepPagination = {
+  id: "deep-pagination",
+  name: "Deep Pagination",
+  description: "Deep pagination with large offsets is slow.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "Slice") {
+        const left = node.left;
+        if (typeof left === "number" && left >= DEEP_PAGINATION_THRESHOLD) {
+          context.report({
+            message: `Slice offset of ${left} is deep pagination. This is slow because all skipped documents must be sorted first.`,
+            severity: "warning",
+            help: 'Use cursor-based pagination with _id instead (e.g., `*[_type == "post" && _id > $lastId] | order(_id)[0...20]`).'
+          });
+        }
+      }
+    });
+  }
+};
+
+// src/rules/deep-pagination-param.ts
+var deepPaginationParam = {
+  id: "deep-pagination-param",
+  name: "Deep Pagination Parameter",
+  description: "Slice offset uses a parameter which could cause deep pagination.",
+  severity: "info",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "Slice") {
+        const left = node.left;
+        if (left && typeof left === "object" && left.type === "Parameter") {
+          const paramNode = left;
+          context.report({
+            message: `Slice offset uses parameter $${paramNode.name}. If given a large value, this will cause slow deep pagination.`,
+            severity: "info",
+            help: "Consider using cursor-based pagination with _id instead, or validate the parameter value."
+          });
+        }
+      }
+    });
+  }
+};
+
+// src/rules/extremely-large-query.ts
+var HUNDRED_KB = 100 * 1024;
+var extremelyLargeQuery = {
+  id: "extremely-large-query",
+  name: "Extremely Large Query",
+  description: "This query is extremely large and will likely execute very slowly.",
+  severity: "error",
+  category: "performance",
+  supersedes: ["very-large-query"],
+  check(_ast, context) {
+    if (context.queryLength > HUNDRED_KB) {
+      context.report({
+        message: `This query is ${formatSize(context.queryLength)}, which is extremely large and will likely execute very slowly. It may be deprioritized by the server.`,
+        severity: "error",
+        help: "Break the query into smaller parts, simplify projections, or reconsider the data model."
+      });
+    }
+  }
+};
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  }
+  return `${bytes} bytes`;
+}
+
+// src/rules/invalid-type-filter.ts
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prevRow = new Array(n + 1);
+  let currRow = new Array(n + 1);
+  for (let j = 0; j <= n; j++) {
+    prevRow[j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    currRow[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      currRow[j] = Math.min(
+        (prevRow[j] ?? 0) + 1,
+        // deletion
+        (currRow[j - 1] ?? 0) + 1,
+        // insertion
+        (prevRow[j - 1] ?? 0) + cost
+        // substitution
+      );
+    }
+    ;
+    [prevRow, currRow] = [currRow, prevRow];
+  }
+  return prevRow[n] ?? 0;
+}
+function findSimilarTypes(typeName, schemaTypes, maxDistance = 3) {
+  return schemaTypes.map((t) => ({
+    type: t,
+    distance: levenshteinDistance(typeName.toLowerCase(), t.toLowerCase())
+  })).filter((t) => t.distance <= maxDistance && t.distance > 0).sort((a, b) => a.distance - b.distance).slice(0, 3).map((t) => t.type);
+}
+function getSchemaDocumentTypes(schema) {
+  return schema.filter((item) => item.type === "document").map((item) => item.name);
+}
+function isTypeComparison(node) {
+  if (node.op !== "==") return null;
+  const { left, right } = node;
+  if (left.type === "AccessAttribute" && left.name === "_type" && right.type === "Value" && typeof right.value === "string") {
+    return { typeName: right.value };
+  }
+  if (right.type === "AccessAttribute" && right.name === "_type" && left.type === "Value" && typeof left.value === "string") {
+    return { typeName: left.value };
+  }
+  return null;
+}
+var invalidTypeFilter = {
+  id: "invalid-type-filter",
+  name: "Invalid Type Filter",
+  description: "Document type in filter does not exist in schema",
+  severity: "error",
+  category: "correctness",
+  requiresSchema: true,
+  check(ast, context) {
+    const { schema } = context;
+    if (!schema) return;
+    const documentTypes = getSchemaDocumentTypes(schema);
+    const documentTypeSet = new Set(documentTypes);
+    walk(ast, (node) => {
+      if (node.type !== "OpCall") return;
+      const typeComparison = isTypeComparison(node);
+      if (!typeComparison) return;
+      const { typeName } = typeComparison;
+      if (!documentTypeSet.has(typeName)) {
+        const similarTypes = findSimilarTypes(typeName, documentTypes);
+        const suggestions = similarTypes.map((t) => ({
+          description: `Change to "${t}"`,
+          replacement: t
+        }));
+        context.report({
+          message: `Document type "${typeName}" does not exist in schema`,
+          severity: "error",
+          help: similarTypes.length > 0 ? `Did you mean: ${similarTypes.map((t) => `"${t}"`).join(", ")}?` : `Available types: ${documentTypes.slice(0, 5).join(", ")}${documentTypes.length > 5 ? "..." : ""}`,
+          suggestions
+        });
+      }
+    });
+  }
+};
+
+// src/rules/join-in-filter.ts
+var joinInFilter = {
+  id: "join-in-filter",
+  name: "Join in Filter",
+  description: "Avoid `->` inside filters. It prevents optimization.",
+  severity: "error",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node, walkContext) => {
+      if (node.type === "Deref" && walkContext.inFilter) {
+        context.report({
+          message: "Avoid joins (`->`) inside filters. It prevents optimization.",
+          severity: "error",
+          help: 'Use `field._ref == $id` instead of `field->attr == "value"`'
+          // Note: groq-js doesn't expose source positions, so we omit span
+          // In a future version, we might add position tracking
+        });
+      }
+    });
+  }
+};
+
+// src/rules/join-to-get-id.ts
+var joinToGetId = {
+  id: "join-to-get-id",
+  name: "Join to Get ID",
+  description: "Avoid using `->` to retrieve `_id`.",
+  severity: "info",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "AccessAttribute" && node.name === "_id") {
+        if (node.base && node.base.type === "Deref") {
+          context.report({
+            message: "Avoid using `->` to retrieve `_id`. Use `._ref` instead.",
+            severity: "info",
+            help: "Replace `reference->_id` with `reference._ref` for better performance."
+          });
+        }
+      }
+    });
+  }
+};
+
+// src/rules/large-pages.ts
+var LARGE_PAGE_THRESHOLD = 100;
+var largePages = {
+  id: "large-pages",
+  name: "Large Pages",
+  description: "Fetching many results at once can be slow.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "Slice") {
+        const left = node.left;
+        const right = node.right;
+        if ((left === 0 || left === void 0) && typeof right === "number") {
+          if (right > LARGE_PAGE_THRESHOLD) {
+            context.report({
+              message: `Fetching ${right} results at once can be slow.`,
+              severity: "warning",
+              help: "Consider breaking into smaller batches and/or using cursor-based pagination."
+            });
+          }
+        }
+      }
+    });
+  }
+};
+
+// src/rules/many-joins.ts
+var MAX_JOINS = 10;
+var manyJoins = {
+  id: "many-joins",
+  name: "Many Joins",
+  description: "This query uses many joins and may have poor performance.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    let joinCount = 0;
+    walk(ast, (node) => {
+      if (node.type === "Deref") {
+        joinCount++;
+      }
+    });
+    if (joinCount > MAX_JOINS) {
+      context.report({
+        message: `This query uses ${joinCount} joins (->), which may cause poor performance.`,
+        severity: "warning",
+        help: "Consider denormalizing data, using fewer reference expansions, or splitting into multiple queries."
+      });
+    }
+  }
+};
+
+// src/rules/match-on-id.ts
+var matchOnId = {
+  id: "match-on-id",
+  name: "Match on ID",
+  description: "`match` on `_id` may not work as expected.",
+  severity: "info",
+  category: "correctness",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "OpCall") {
+        const op = node.op;
+        if (op !== "match") return;
+        const left = node.left;
+        if (left && left.type === "AccessAttribute") {
+          const name = left.name;
+          if (name === "_id") {
+            context.report({
+              message: "`match` is designed for full-text matching and may not work as expected on `_id`.",
+              severity: "info",
+              help: "Consider using `==` for exact matches or `string::startsWith()` for prefix matching."
+            });
+          }
+        }
+      }
+    });
+  }
+};
+
+// src/rules/non-literal-comparison.ts
+var COMPARISON_OPS = ["==", "!=", "<", ">", "<=", ">="];
+function containsParentRef3(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "Parent") {
+      found = true;
+    }
+  });
+  return found;
+}
+function isLiteral2(node) {
+  if (node.type === "Value") return true;
+  if (node.type === "Parameter") return true;
+  if (node.type === "FuncCall" && node.name === "now") return true;
+  if (node.type === "OpCall") {
+    const op = node.op;
+    if (["+", "-", "*", "/"].includes(op ?? "")) {
+      const left = node.left;
+      const right = node.right;
+      if (left && right && isLiteral2(left) && isLiteral2(right)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var nonLiteralComparison = {
+  id: "non-literal-comparison",
+  name: "Non-Literal Comparison",
+  description: "Comparisons between two non-literal fields are slow.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node, walkContext) => {
+      if (!walkContext.inFilter) return;
+      if (node.type === "OpCall") {
+        const op = node.op;
+        if (!COMPARISON_OPS.includes(op ?? "")) return;
+        const left = node.left;
+        const right = node.right;
+        if (!left || !right) return;
+        if (containsParentRef3(left) || containsParentRef3(right)) return;
+        if (!isLiteral2(left) && !isLiteral2(right)) {
+          context.report({
+            message: "Comparing two non-literal expressions prevents efficient index usage.",
+            severity: "warning",
+            help: "Consider adding additional filters to reduce the search space."
+          });
+        }
+      }
+    });
+  }
+};
+
+// src/rules/order-on-expr.ts
+function isSimpleAttribute(node) {
+  return node.type === "AccessAttribute";
+}
+function isAllowedWrappedAttribute(node) {
+  if (node.type !== "FuncCall") return false;
+  const name = node.name;
+  const namespace = node.namespace;
+  const args = node.args ?? [];
+  if (name === "lower" && namespace === "global" && args.length === 1) {
+    const arg = args[0];
+    return arg !== void 0 && isSimpleAttribute(arg);
+  }
+  if (name === "dateTime" && namespace === "global" && args.length === 1) {
+    const arg = args[0];
+    return arg !== void 0 && isSimpleAttribute(arg);
+  }
+  if (name === "distance" && namespace === "geo" && args.length === 2) {
+    const arg0 = args[0];
+    const arg1 = args[1];
+    return arg0 !== void 0 && arg1 !== void 0 && isSimpleAttribute(arg0) && arg1.type === "Value";
+  }
+  return false;
+}
+function isValidOrderArg(node) {
+  if (isSimpleAttribute(node)) return true;
+  if (isAllowedWrappedAttribute(node)) return true;
+  if (node.type === "Asc" || node.type === "Desc") {
+    const base = node.base;
+    if (base) {
+      return isSimpleAttribute(base) || isAllowedWrappedAttribute(base);
+    }
+  }
+  return false;
+}
+var orderOnExpr = {
+  id: "order-on-expr",
+  name: "Order on Expression",
+  description: "Ordering on computed values is slow.",
+  severity: "warning",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node) => {
+      if (node.type === "PipeFuncCall") {
+        const name = node.name;
+        if (name !== "order") return;
+        const args = node.args ?? [];
+        for (const arg of args) {
+          if (!isValidOrderArg(arg)) {
+            context.report({
+              message: "Ordering on computed expression prevents index usage.",
+              severity: "warning",
+              help: "Use simple attributes or allowed functions (lower, dateTime, geo::distance) for ordering."
+            });
+          }
+        }
+      }
+    });
+  }
+};
+
+// src/rules/repeated-dereference.ts
+function getDerefBaseName(node) {
+  if (node.type !== "Deref") return null;
+  const base = node.base;
+  if (!base) return null;
+  let current = base;
+  while (current.type === "AccessAttribute" && current.base) {
+    current = current.base;
+  }
+  if (current.type === "AccessAttribute") {
+    return current.name ?? null;
+  }
+  return null;
+}
+var repeatedDereference = {
+  id: "repeated-dereference",
+  name: "Repeated Dereference",
+  description: "Repeatedly resolving the same reference is inefficient.",
+  severity: "info",
+  category: "performance",
+  check(ast, context) {
+    walk(ast, (node, _walkContext) => {
+      if (node.type !== "Projection") return;
+      const projectionExpr = node.expr;
+      if (!projectionExpr) return;
+      const derefCounts = /* @__PURE__ */ new Map();
+      walk(projectionExpr, (innerNode) => {
+        if (innerNode.type === "Deref") {
+          const baseName = getDerefBaseName(innerNode);
+          if (baseName) {
+            derefCounts.set(baseName, (derefCounts.get(baseName) ?? 0) + 1);
+          }
+        }
+      });
+      for (const [name, count] of derefCounts) {
+        if (count > 1) {
+          context.report({
+            message: `Reference '${name}' is dereferenced ${count} times. Consider a single sub-projection.`,
+            severity: "info",
+            help: `Replace multiple '${name}->...' with '${name}->{ ... }' to resolve the reference once.`
+          });
+        }
+      }
+    });
+  }
+};
+
+// src/rules/unknown-field.ts
+function levenshteinDistance2(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prevRow = new Array(n + 1);
+  let currRow = new Array(n + 1);
+  for (let j = 0; j <= n; j++) {
+    prevRow[j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    currRow[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      currRow[j] = Math.min(
+        (prevRow[j] ?? 0) + 1,
+        (currRow[j - 1] ?? 0) + 1,
+        (prevRow[j - 1] ?? 0) + cost
+      );
+    }
+    ;
+    [prevRow, currRow] = [currRow, prevRow];
+  }
+  return prevRow[n] ?? 0;
+}
+function findSimilarFields(fieldName, availableFields, maxDistance = 3) {
+  return availableFields.map((f) => ({
+    field: f,
+    distance: levenshteinDistance2(fieldName.toLowerCase(), f.toLowerCase())
+  })).filter((f) => f.distance <= maxDistance && f.distance > 0).sort((a, b) => a.distance - b.distance).slice(0, 3).map((f) => f.field);
+}
+function extractTypeFromFilter(node) {
+  if (node.type === "OpCall") {
+    const opNode = node;
+    if (opNode.op !== "==") return null;
+    const { left, right } = opNode;
+    if (left.type === "AccessAttribute" && left.name === "_type" && right.type === "Value" && typeof right.value === "string") {
+      return right.value;
+    }
+    if (right.type === "AccessAttribute" && right.name === "_type" && left.type === "Value" && typeof left.value === "string") {
+      return left.value;
+    }
+  }
+  if (node.type === "And") {
+    const leftType = extractTypeFromFilter(node.left);
+    if (leftType) return leftType;
+    return extractTypeFromFilter(node.right);
+  }
+  return null;
+}
+function findDocumentTypeFromFilter(filterBase) {
+  if (filterBase.type === "Filter") {
+    return extractTypeFromFilter(filterBase.expr);
+  }
+  return null;
+}
+function getFieldsForType(schema, typeName) {
+  const doc = schema.find((item) => item.type === "document" && item.name === typeName);
+  if (!doc?.attributes) return [];
+  return Object.keys(doc.attributes);
+}
+var BUILT_IN_FIELDS = /* @__PURE__ */ new Set(["_id", "_type", "_rev", "_createdAt", "_updatedAt"]);
+function checkObjectFields(objNode, documentType, availableFieldsSet, schemaFields, context) {
+  for (const attr of objNode.attributes) {
+    if (attr.type === "ObjectAttributeValue") {
+      const value = attr.value;
+      if (value.type === "AccessAttribute" && !value.base) {
+        const fieldName = value.name;
+        if (availableFieldsSet.has(fieldName)) continue;
+        const similarFields = findSimilarFields(fieldName, [...availableFieldsSet]);
+        const suggestions = similarFields.map((f) => ({
+          description: `Change to "${f}"`,
+          replacement: f
+        }));
+        context.report({
+          message: `Field "${fieldName}" does not exist on type "${documentType}"`,
+          severity: "warning",
+          help: similarFields.length > 0 ? `Did you mean: ${similarFields.map((f) => `"${f}"`).join(", ")}?` : `Available fields: ${schemaFields.slice(0, 5).join(", ")}${schemaFields.length > 5 ? "..." : ""}`,
+          suggestions
+        });
+      }
+    }
+  }
+}
+var unknownField = {
+  id: "unknown-field",
+  name: "Unknown Field",
+  description: "Field in projection does not exist in schema",
+  severity: "warning",
+  category: "correctness",
+  requiresSchema: true,
+  check(ast, context) {
+    const { schema } = context;
+    if (!schema) return;
+    walk(ast, (node) => {
+      if (node.type === "Map") {
+        const mapNode = node;
+        const documentType = findDocumentTypeFromFilter(mapNode.base);
+        if (!documentType) return;
+        if (mapNode.expr.type !== "Projection") return;
+        const projection = mapNode.expr;
+        if (projection.expr.type !== "Object") return;
+        const objNode = projection.expr;
+        const schemaFields = getFieldsForType(
+          schema,
+          documentType
+        );
+        if (schemaFields.length === 0) return;
+        const availableFields = [...schemaFields, ...BUILT_IN_FIELDS];
+        const availableFieldsSet = new Set(availableFields);
+        checkObjectFields(objNode, documentType, availableFieldsSet, schemaFields, context);
+      }
+    });
+  }
+};
+
+// src/rules/very-large-query.ts
+var TEN_KB = 10 * 1024;
+var veryLargeQuery = {
+  id: "very-large-query",
+  name: "Very Large Query",
+  description: "This query is very large and may execute slowly.",
+  severity: "warning",
+  category: "performance",
+  check(_ast, context) {
+    if (context.queryLength > TEN_KB) {
+      context.report({
+        message: `This query is ${formatSize2(context.queryLength)}, which is very large and may execute slowly. It may be deprioritized by the server.`,
+        severity: "warning",
+        help: "Consider breaking the query into smaller parts or simplifying projections."
+      });
+    }
+  }
+};
+function formatSize2(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  }
+  return `${bytes} bytes`;
+}
+
+// src/rules/index.ts
+var rules = [
+  // Performance - query size
+  veryLargeQuery,
+  extremelyLargeQuery,
+  // Performance - joins
+  joinInFilter,
+  joinToGetId,
+  manyJoins,
+  repeatedDereference,
+  // Performance - pagination
+  deepPagination,
+  deepPaginationParam,
+  largePages,
+  // Performance - filtering
+  computedValueInFilter,
+  nonLiteralComparison,
+  // Performance - ordering
+  orderOnExpr,
+  // Performance - aggregation
+  countInCorrelatedSubquery,
+  // Correctness
+  matchOnId,
+  // Schema-aware correctness (requires schema to run)
+  invalidTypeFilter,
+  unknownField
+];
+var rulesById = Object.fromEntries(
+  rules.map((rule) => [rule.id, rule])
+);
+
+// src/wasm-linter.ts
+var wasmAvailable = false;
+var wasmInitialized = false;
+var wasmInitPromise = null;
+var wasmModule = null;
+var WASM_RULES = /* @__PURE__ */ new Set([
+  "join-in-filter",
+  "join-to-get-id",
+  "computed-value-in-filter",
+  "match-on-id",
+  "order-on-expr",
+  "deep-pagination",
+  "large-pages",
+  "non-literal-comparison",
+  "repeated-dereference",
+  "count-in-correlated-subquery",
+  "very-large-query",
+  "extremely-large-query",
+  "many-joins"
+]);
+function isWasmRule(ruleId) {
+  return WASM_RULES.has(ruleId);
+}
+async function initWasmLinter() {
+  if (wasmInitialized) {
+    return wasmAvailable;
+  }
+  if (wasmInitPromise) {
+    return wasmInitPromise;
+  }
+  wasmInitPromise = doInit();
+  return wasmInitPromise;
+}
+async function doInit() {
+  try {
+    wasmModule = await import("@sanity/groq-wasm");
+    await wasmModule.initWasm();
+    wasmAvailable = true;
+    wasmInitialized = true;
+    return true;
+  } catch {
+    wasmAvailable = false;
+    wasmInitialized = true;
+    return false;
+  }
+}
+function isWasmAvailable() {
+  return wasmAvailable;
+}
+function lintWithWasm(query, enabledRules) {
+  if (!wasmAvailable || !wasmModule) {
+    throw new Error("WASM linter not initialized. Call initWasmLinter() first.");
+  }
+  const wasmFindings = wasmModule.lint(query);
+  if (enabledRules) {
+    return wasmFindings.filter((f) => enabledRules.has(f.ruleId));
+  }
+  return wasmFindings;
+}
+
+// src/linter.ts
+async function initLinter() {
+  return initWasmLinter();
+}
+function lint(query, options) {
+  const { config, schema, forceTs = false } = options ?? {};
+  const findings = [];
+  if (!query.trim()) {
+    return { query, findings };
+  }
+  const enabledRules = getEnabledRules(config, schema);
+  const wasmRuleIds = /* @__PURE__ */ new Set();
+  const tsRules = [];
+  for (const rule of enabledRules) {
+    if (!forceTs && isWasmAvailable() && isWasmRule(rule.id)) {
+      wasmRuleIds.add(rule.id);
+    } else {
+      tsRules.push(rule);
+    }
+  }
+  const wasmFindings = [];
+  if (wasmRuleIds.size > 0 && isWasmAvailable()) {
+    try {
+      const wf = lintWithWasm(query, wasmRuleIds);
+      wasmFindings.push(...wf);
+    } catch {
+      for (const ruleId of wasmRuleIds) {
+        const rule = enabledRules.find((r) => r.id === ruleId);
+        if (rule) {
+          tsRules.push(rule);
+        }
+      }
+      wasmRuleIds.clear();
+    }
+  }
+  let ast;
+  if (tsRules.length > 0) {
+    try {
+      ast = parse(query);
+    } catch (error) {
+      return {
+        query,
+        findings: wasmFindings,
+        // Return any WASM findings we got
+        parseError: error instanceof Error ? error.message : "Unknown parse error"
+      };
+    }
+  }
+  const firedRules = /* @__PURE__ */ new Set();
+  for (const f of wasmFindings) {
+    firedRules.add(f.ruleId);
+  }
+  const tsFindings = [];
+  if (ast) {
+    for (const rule of tsRules) {
+      const ruleFindings = [];
+      const context = {
+        query,
+        queryLength: query.length,
+        ...schema && { schema },
+        report: (finding) => {
+          ruleFindings.push({
+            ...finding,
+            ruleId: rule.id,
+            severity: finding.severity ?? rule.severity
+          });
+        }
+      };
+      rule.check(ast, context);
+      if (ruleFindings.length > 0) {
+        firedRules.add(rule.id);
+        tsFindings.push(...ruleFindings);
+      }
+    }
+  }
+  const allFindings = [...wasmFindings, ...tsFindings];
+  for (const finding of allFindings) {
+    const rule = enabledRules.find((r) => r.id === finding.ruleId);
+    if (rule?.supersedes) {
+      const isSuperseded = enabledRules.some(
+        (r) => r.supersedes?.includes(finding.ruleId) && firedRules.has(r.id)
+      );
+      if (!isSuperseded) {
+        findings.push(finding);
+      }
+    } else {
+      findings.push(finding);
+    }
+  }
+  return { query, findings };
+}
+function getEnabledRules(config, schema) {
+  let rules2 = rules;
+  if (!schema) {
+    rules2 = rules2.filter((rule) => !rule.requiresSchema);
+  }
+  if (!config?.rules) {
+    return rules2;
+  }
+  return rules2.filter((rule) => {
+    const ruleConfig = config.rules?.[rule.id];
+    if (ruleConfig === false) {
+      return false;
+    }
+    if (typeof ruleConfig === "object" && ruleConfig.enabled === false) {
+      return false;
+    }
+    return true;
+  });
+}
+
+// src/cli.ts
 import { formatFindings, summarizeFindings } from "@sanity/lint-core";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -125,8 +1145,8 @@ async function expandGlobs(patterns) {
 }
 async function main() {
   const options = parseArgs(process.argv.slice(2));
-  const wasmAvailable = await initLinter();
-  if (wasmAvailable) {
+  const wasmAvailable2 = await initLinter();
+  if (wasmAvailable2) {
   }
   const schema = options.schema ? loadSchema(options.schema) : void 0;
   if (options.schema && schema) {