@lunora/advisor 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/packem_shared/constraintValidator-Dr9Py3FD.mjs

@@ -1,186 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const MAX_EXAMPLE_IDS = 5;
-const rowId = (row) => typeof row["_id"] === "string" ? row["_id"] : "?";
-const truncatedSuffix = (capped, cap, phrase) => capped ? ` (sample capped at ${cap.toString()} rows — ${phrase})` : "";
-const formatExamples = (ids, total) => {
-  const examples = ids.slice(0, MAX_EXAMPLE_IDS);
-  const more = total - examples.length;
-  const list = examples.map((id) => `"${id}"`).join(", ");
-  return more > 0 ? `${list} (+${more.toString()} more)` : list;
-};
-const checkFkRelation = (lint, sample, relation, targetSample) => {
-  if (relation.kind !== "one") {
-    return void 0;
-  }
-  const fkColumn = relation.field;
-  const danglingIds = [];
-  for (const row of sample.rows) {
-    const fkValue = row[fkColumn];
-    if (fkValue === null || fkValue === void 0) {
-      continue;
-    }
-    const fkString = String(fkValue);
-    if (!targetSample.existingIds.has(fkString)) {
-      danglingIds.push(rowId(row));
-    }
-  }
-  if (danglingIds.length === 0) {
-    return void 0;
-  }
-  const isTruncated = sample.truncated || targetSample.truncated;
-  const cap = Math.min(sample.cap, targetSample.cap);
-  const detail = `Table "${sample.table}": ${danglingIds.length.toString()} sampled row(s) have a dangling FK value in column "${fkColumn}" — the referenced "${relation.table}" row does not exist. Row ids: ${formatExamples(danglingIds, danglingIds.length)}${truncatedSuffix(isTruncated, cap, "more rows may exist beyond the window")}.`;
-  return emit(lint, {
-    cacheKey: `constraint_validator:fk:${sample.table}:${fkColumn}`,
-    detail,
-    metadata: {
-      cap,
-      column: fkColumn,
-      count: danglingIds.length,
-      examples: danglingIds.slice(0, MAX_EXAMPLE_IDS),
-      kind: "fk",
-      referencesTable: relation.table,
-      table: sample.table,
-      truncated: isTruncated
-    }
-  });
-};
-const checkNullField = (lint, sample, field, isRequired) => {
-  if (!isRequired) {
-    return void 0;
-  }
-  const nullIds = [];
-  for (const row of sample.rows) {
-    const value = row[field];
-    if (value === null || value === void 0) {
-      nullIds.push(rowId(row));
-    }
-  }
-  if (nullIds.length === 0) {
-    return void 0;
-  }
-  const detail = `Table "${sample.table}": ${nullIds.length.toString()} sampled row(s) have a null/missing value in column "${field}", which is declared as non-optional. Row ids: ${formatExamples(nullIds, nullIds.length)}${truncatedSuffix(sample.truncated, sample.cap, "more rows may exist beyond the window")}.`;
-  return emit(lint, {
-    cacheKey: `constraint_validator:null:${sample.table}:${field}`,
-    detail,
-    metadata: {
-      cap: sample.cap,
-      column: field,
-      count: nullIds.length,
-      examples: nullIds.slice(0, MAX_EXAMPLE_IDS),
-      kind: "null",
-      table: sample.table,
-      truncated: sample.truncated
-    }
-  });
-};
-const compositeKey = (row, fields) => {
-  const parts = [];
-  for (const field of fields) {
-    const value = row[field];
-    if (value === null || value === void 0) {
-      return void 0;
-    }
-    parts.push(JSON.stringify(value));
-  }
-  return parts.join("|");
-};
-const recordDuplicate = (id, existingId, duplicateIds) => {
-  if (!duplicateIds.includes(existingId)) {
-    duplicateIds.push(existingId);
-  }
-  duplicateIds.push(id);
-};
-const checkUniqueIndex = (lint, sample, index) => {
-  if (index.kind !== "index" || index.unique !== true) {
-    return void 0;
-  }
-  const seen = /* @__PURE__ */ new Map();
-  const duplicateIds = [];
-  for (const row of sample.rows) {
-    const id = rowId(row);
-    const key = compositeKey(row, index.fields);
-    if (key === void 0) {
-      continue;
-    }
-    const existingId = seen.get(key);
-    if (existingId === void 0) {
-      seen.set(key, id);
-    } else {
-      recordDuplicate(id, existingId, duplicateIds);
-    }
-  }
-  if (duplicateIds.length === 0) {
-    return void 0;
-  }
-  const detail = `Table "${sample.table}": ${duplicateIds.length.toString()} sampled row(s) share duplicate values on unique index "${index.name}" (${index.fields.join(", ")}). Row ids: ${formatExamples(duplicateIds, duplicateIds.length)}${truncatedSuffix(sample.truncated, sample.cap, "duplicates beyond the window may exist")}.`;
-  return emit(lint, {
-    cacheKey: `constraint_validator:unique:${sample.table}:${index.name}`,
-    detail,
-    metadata: {
-      cap: sample.cap,
-      count: duplicateIds.length,
-      examples: duplicateIds.slice(0, MAX_EXAMPLE_IDS),
-      fields: index.fields,
-      index: index.name,
-      kind: "unique",
-      table: sample.table,
-      truncated: sample.truncated
-    }
-  });
-};
-const checkTable = (lint, sample, sampleByTable, tableByName) => {
-  const schemaTable = tableByName.get(sample.table);
-  if (!schemaTable) {
-    return [];
-  }
-  const findings = [];
-  for (const relation of schemaTable.relations) {
-    const targetSample = sampleByTable.get(relation.table);
-    if (!targetSample) {
-      continue;
-    }
-    const f = checkFkRelation(lint, sample, relation, targetSample);
-    if (f) {
-      findings.push(f);
-    }
-  }
-  for (const field of schemaTable.fields) {
-    const isRequired = !schemaTable.optionalFields?.has(field);
-    const f = checkNullField(lint, sample, field, isRequired);
-    if (f) {
-      findings.push(f);
-    }
-  }
-  for (const index of schemaTable.indexes) {
-    const f = checkUniqueIndex(lint, sample, index);
-    if (f) {
-      findings.push(f);
-    }
-  }
-  return findings;
-};
-const constraintValidator = {
-  categories: ["SCHEMA"],
-  description: "Sampled rows violate one or more declared constraints: a foreign-key column references a non-existent row, a non-optional column contains null, or a unique-indexed column has duplicate values. These violations indicate data inserted before a constraint was enforced (e.g. a schema migration, a raw import, or a bug in a past data-migration transform).",
-  facing: "INTERNAL",
-  level: "WARN",
-  name: "constraint_validator",
-  remediation: "Inspect the listed rows and correct or remove the violating values. Run a data migration to backfill nulls, dedup unique violations, or re-link dangling FK references. For FK violations, confirm the target table rows exist before fixing the referencing rows.",
-  run: (context) => {
-    if (!context.tableSamples || context.tableSamples.length === 0) {
-      return [];
-    }
-    const sampleByTable = /* @__PURE__ */ new Map();
-    for (const sample of context.tableSamples) {
-      sampleByTable.set(sample.table, sample);
-    }
-    const tableByName = new Map(context.schema.tables.map((table) => [table.name, table]));
-    return context.tableSamples.flatMap((sample) => checkTable(constraintValidator, sample, sampleByTable, tableByName));
-  },
-  source: "runtime",
-  title: "Constraint violation"
-};
-
-export { constraintValidator as default };

package/dist/packem_shared/containerOversizedInstance-5U1VKPRM.mjs

@@ -1,36 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const LARGE_NAMED = /* @__PURE__ */ new Set(["standard-3", "standard-4"]);
-const VCPU_THRESHOLD = 2;
-const MEMORY_MIB_THRESHOLD = 4096;
-const isOversized = (instanceType) => typeof instanceType === "string" ? LARGE_NAMED.has(instanceType) : (instanceType.vcpu ?? 0) > VCPU_THRESHOLD || (instanceType.memoryMib ?? 0) > MEMORY_MIB_THRESHOLD;
-const containerOversizedInstance = {
-  categories: ["PERFORMANCE"],
-  description: "A container is declared on a large instance type, whose provisioned memory and disk are billed for the lifetime of every running instance.",
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "container_oversized_instance",
-  remediation: "Confirm the workload needs this size; a smaller instanceType (lite/basic/standard-1) costs less while idle-but-running.",
-  run: (context) => {
-    const findings = [];
-    for (const container of context.containers ?? []) {
-      const { instanceType } = container;
-      if (instanceType === void 0 || !isOversized(instanceType)) {
-        continue;
-      }
-      const size = typeof instanceType === "string" ? instanceType : JSON.stringify(instanceType);
-      findings.push(
-        emit(containerOversizedInstance, {
-          cacheKey: `container_oversized_instance:${container.exportName}`,
-          detail: `Container "${container.exportName}" uses a large instance type (${size}); its memory + disk are billed while any instance runs.`,
-          metadata: { container: container.exportName, instanceType }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Oversized container instance"
-};
-
-export { containerOversizedInstance as default };

package/dist/packem_shared/containerPublicInternet-CuNerJE5.mjs

@@ -1,30 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const containerPublicInternet = {
-  categories: ["SECURITY"],
-  description: "A container leaves outbound internet access at the default (enabled), which is billed per GB of egress and widens the attack surface.",
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "container_public_internet",
-  remediation: "Set `enableInternet: false` on the container if it doesn't call external services, or `true` to opt in deliberately.",
-  run: (context) => {
-    const findings = [];
-    for (const container of context.containers ?? []) {
-      if (container.enableInternet !== void 0) {
-        continue;
-      }
-      findings.push(
-        emit(containerPublicInternet, {
-          cacheKey: `container_public_internet:${container.exportName}`,
-          detail: `Container "${container.exportName}" doesn't set enableInternet, so outbound internet is on by default (egress is billed).`,
-          metadata: { container: container.exportName }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Container egress enabled by default"
-};
-
-export { containerPublicInternet as default };

package/dist/packem_shared/duplicateIndex-BOublMSt.mjs

@@ -1,57 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const isLeadingPrefix = (a, b) => {
-  if (a.length > b.length) {
-    return false;
-  }
-  return a.every((field, position) => field === b[position]);
-};
-const duplicateIndex = {
-  categories: ["PERFORMANCE"],
-  description: "A secondary index is redundant because another index already covers every lookup it serves (its columns are a leading prefix of the other's). The redundant index costs storage and is maintained on every write for no read benefit.",
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "duplicate_index",
-  remediation: "Drop the redundant index; the covering index already serves its lookups.",
-  run: (context) => {
-    const findings = [];
-    for (const table of context.schema.tables) {
-      const secondary = table.indexes.filter((index) => index.kind === "index");
-      for (const candidate of secondary) {
-        if (candidate.unique === true) {
-          continue;
-        }
-        const cover = secondary.find((other) => {
-          if (other === candidate) {
-            return false;
-          }
-          if (!isLeadingPrefix(candidate.fields, other.fields)) {
-            return false;
-          }
-          const sameLength = candidate.fields.length === other.fields.length;
-          return sameLength ? candidate.name > other.name : true;
-        });
-        if (!cover) {
-          continue;
-        }
-        findings.push(
-          emit(duplicateIndex, {
-            cacheKey: `duplicate_index:${table.name}:${candidate.name}`,
-            detail: `Index "${candidate.name}" on table "${table.name}" (${candidate.fields.join(", ")}) is redundant — index "${cover.name}" (${cover.fields.join(", ")}) already covers its lookups.`,
-            metadata: {
-              coveredBy: { fields: cover.fields, name: cover.name },
-              fields: candidate.fields,
-              index: candidate.name,
-              table: table.name
-            }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Duplicate / redundant index"
-};
-
-export { duplicateIndex as default };

package/dist/packem_shared/emptyIndex-BX8EuEY7.mjs

@@ -1,32 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const emptyIndex = {
-  categories: ["SCHEMA"],
-  description: "An index declares no columns, so it indexes nothing and can never narrow a read.",
-  facing: "INTERNAL",
-  level: "WARN",
-  name: "empty_index",
-  remediation: "Give the index its columns, or remove it.",
-  run: (context) => {
-    const findings = [];
-    for (const table of context.schema.tables) {
-      for (const index of table.indexes) {
-        if (index.kind !== "index" || index.fields.length > 0) {
-          continue;
-        }
-        findings.push(
-          emit(emptyIndex, {
-            cacheKey: `empty_index:${table.name}:${index.name}`,
-            detail: `Index "${index.name}" on table "${table.name}" declares no columns.`,
-            metadata: { index: index.name, table: table.name }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Empty index"
-};
-
-export { emptyIndex as default };

package/dist/packem_shared/filterWithoutIndex-BYVeJaSs.mjs

@@ -1,31 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const filterWithoutIndex = {
-  categories: ["PERFORMANCE"],
-  description: "A query calls `.filter()` without a `.withIndex()` / `.withSearchIndex()`, so it loads every row in the table and filters in memory — a full table scan that gets linearly slower as the table grows.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "filter_without_index",
-  remediation: 'Narrow the read with `.withIndex("name", (q) => q.eq(...))` first, then `.filter()` only for what the index cannot express.',
-  run: (context) => {
-    const findings = [];
-    for (const read of context.queries ?? []) {
-      if (!read.hasFilter || read.hasIndex || read.table === "") {
-        continue;
-      }
-      const location = read.line > 0 ? `${read.file}:${read.line.toString()}` : read.file;
-      findings.push(
-        emit(filterWithoutIndex, {
-          cacheKey: `filter_without_index:${read.file}:${read.line.toString()}:${read.table}`,
-          detail: `Query on "${read.table}" at ${location} calls .filter() without an index — it loads every row of "${read.table}" and filters in memory.`,
-          metadata: { file: read.file, line: read.line, table: read.table }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Filter without index"
-};
-
-export { filterWithoutIndex as default };

package/dist/packem_shared/finding-Dm_zvzS1.mjs

@@ -1,16 +0,0 @@
-const emit = (lint, occurrence) => {
-  return {
-    cacheKey: occurrence.cacheKey,
-    categories: occurrence.categories ?? lint.categories,
-    description: lint.description,
-    detail: occurrence.detail,
-    facing: occurrence.facing ?? lint.facing,
-    level: occurrence.level ?? lint.level,
-    metadata: occurrence.metadata,
-    name: lint.name,
-    remediation: lint.remediation,
-    title: lint.title
-  };
-};
-
-export { emit as e };

package/dist/packem_shared/fk-index-IUK1ukgs.mjs

@@ -1,7 +0,0 @@
-const PRIMARY_KEY = "_id";
-const suggestIndexName = (field) => `by${field.charAt(0).toUpperCase()}${field.slice(1)}`;
-const leadingIndexedColumns = (table) => new Set(
-  table.indexes.filter((index) => index.kind === "index").map((index) => index.fields[0]).filter((field) => field !== void 0)
-);
-
-export { PRIMARY_KEY as P, leadingIndexedColumns as l, suggestIndexName as s };

package/dist/packem_shared/fromServerSchema-DinF1nph.mjs

@@ -1,50 +0,0 @@
-const fromServerSchema = (schema) => {
-  return {
-    tables: Object.entries(schema.tables).map(([name, table]) => {
-      const indexes = [
-        ...table.indexes.map((index) => {
-          return { fields: index.fields, kind: "index", name: index.name, unique: index.unique };
-        }),
-        ...table.searchIndexes.map((index) => {
-          return { fields: [index.field, ...index.filterFields ?? []], kind: "search", name: index.name };
-        }),
-        ...table.rankIndexes.map((index) => {
-          return { fields: [...index.sortBy.map((key) => key.field), ...index.partitionBy ?? []], kind: "rank", name: index.name };
-        }),
-        ...table.vectorIndexes.map((index) => {
-          return { fields: [index.field], kind: "vector", name: index.name };
-        })
-      ];
-      const optionalFields = /* @__PURE__ */ new Set();
-      for (const [fieldName, validator] of Object.entries(table.shape)) {
-        if (validator.kind === "optional") {
-          optionalFields.add(fieldName);
-        } else {
-          const column = validator._meta?.column;
-          if (column?.notNull === false) {
-            optionalFields.add(fieldName);
-          }
-        }
-      }
-      return {
-        externallyManaged: table.isExternallyManaged ?? false,
-        fields: Object.keys(table.shape),
-        indexes,
-        name,
-        optionalFields,
-        relations: Object.entries(table.relationMap).map(([accessor, relation]) => {
-          return {
-            field: relation.field,
-            kind: relation.kind,
-            name: accessor,
-            onDelete: relation.onDelete,
-            references: relation.references,
-            table: relation.table
-          };
-        })
-      };
-    })
-  };
-};
-
-export { fromServerSchema };

package/dist/packem_shared/hardcodedSecret-W2pz1UZB.mjs

@@ -1,35 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const hardcodedSecret = {
-  categories: ["SECURITY"],
-  description: "A secret-shaped string literal (live API key, access key, private key, or high-entropy token) is hard-coded in the source. Committed secrets leak via clone/fork/history and force a redeploy to rotate.",
-  facing: "INTERNAL",
-  level: "ERROR",
-  name: "hardcoded_secret",
-  remediation: 'Move the secret out of source: set it locally in `.dev.vars` (`lunora env set <NAME> "<value>"`) and in production with `wrangler secret put <NAME>`, then read it at runtime from `env.<NAME>`. Rotate the exposed value — assume it is already compromised.',
-  run: (context) => {
-    if (context.secretLiterals === void 0) {
-      return [];
-    }
-    const findings = [];
-    const occurrenceCount = /* @__PURE__ */ new Map();
-    for (const secret of context.secretLiterals) {
-      const baseKey = `${secret.file}:${secret.line.toString()}:${secret.kind}`;
-      const occurrence = (occurrenceCount.get(baseKey) ?? 0) + 1;
-      occurrenceCount.set(baseKey, occurrence);
-      const occurrenceSuffix = occurrence > 1 ? `:${occurrence.toString()}` : "";
-      findings.push(
-        emit(hardcodedSecret, {
-          cacheKey: `hardcoded_secret:${baseKey}${occurrenceSuffix}`,
-          detail: `A ${secret.kind.replaceAll("_", " ")} (${secret.preview}) is hard-coded at ${secret.file}:${secret.line.toString()}. Move it to \`.dev.vars\` / \`wrangler secret put\` and read it from \`env\`. Rotate the exposed value.`,
-          metadata: { file: secret.file, kind: secret.kind, line: secret.line, preview: secret.preview }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Hard-coded secret in source"
-};
-
-export { hardcodedSecret as default };

package/dist/packem_shared/helpers-DNCkMWZQ.mjs

@@ -1,4 +0,0 @@
-const SYSTEM_FIELDS = /* @__PURE__ */ new Set(["_creationTime", "_id"]);
-const tableColumnSet = (table) => /* @__PURE__ */ new Set([...SYSTEM_FIELDS, ...table.fields]);
-
-export { tableColumnSet as t };

package/dist/packem_shared/hotShard-Ir5D0B6J.mjs

@@ -1,48 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const HOT_SHARE_THRESHOLD = 0.5;
-const MIN_TOTAL_REQUESTS = 50;
-const hotShard = {
-  categories: ["PERFORMANCE"],
-  description: "One shard is taking a disproportionate share of a sharded function's traffic, so the busy shard becomes a single-DO bottleneck while its siblings sit idle — the hot-key skew sharding is meant to avoid.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "hot_shard",
-  remediation: "Re-shard on a higher-cardinality / more evenly-distributed key, or split the hot entity's state, so request volume spreads across shards instead of concentrating on one.",
-  run: (context) => {
-    const active = (context.shardTraffic ?? []).filter((shard) => shard.requests > 0);
-    const totalRequests = active.reduce((sum, shard) => sum + shard.requests, 0);
-    if (active.length < 2 || totalRequests < MIN_TOTAL_REQUESTS) {
-      return [];
-    }
-    const findings = [];
-    for (const shard of active) {
-      const share = shard.requests / totalRequests;
-      if (share < HOT_SHARE_THRESHOLD) {
-        continue;
-      }
-      const scope = shard.group !== void 0 && shard.group !== "" ? `"${shard.group}" ` : "";
-      const label = shard.shardKey === "" ? "the root shard" : `shard "${shard.shardKey}"`;
-      const percent = Math.round(share * 100);
-      findings.push(
-        emit(hotShard, {
-          cacheKey: `hot_shard:${shard.group ?? ""}:${shard.shardKey}`,
-          detail: `${scope}${label} handled ${shard.requests.toString()} of ${totalRequests.toString()} requests (${percent.toString()}%) across ${active.length.toString()} shards — a hot-key skew. Re-shard on a more evenly-distributed key.`,
-          metadata: {
-            group: shard.group,
-            requests: shard.requests,
-            shardCount: active.length,
-            shardKey: shard.shardKey,
-            share,
-            totalRequests
-          }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "runtime",
-  title: "Hot shard"
-};
-
-export { hotShard as default };

package/dist/packem_shared/hyperdriveOutsideAction-BgZqX7Xg.mjs

@@ -1,30 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const hyperdriveOutsideAction = {
-  categories: ["SCHEMA"],
-  description: "A `query`/`mutation` handler accesses Hyperdrive via `ctx.sql`. Hyperdrive hits an external database Lunora does not own: queries are non-deterministic (like `fetch`) and external writes are invisible to live queries. `ctx.sql` is available on `ActionCtx` only and must be confined to `action` handlers.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "hyperdrive_outside_action",
-  remediation: "Move the `ctx.sql` access into an `action(...)` (the only context where it is typed), where external I/O is allowed. If a query/mutation needs the data, have the action read it via `ctx.sql` and write a projection into a `defineSchema` DO/D1 table — that write is tracked by live queries, whereas the external DB is not.",
-  run: (context) => {
-    if (context.hyperdriveCalls === void 0) {
-      return [];
-    }
-    const findings = [];
-    for (const call of context.hyperdriveCalls) {
-      findings.push(
-        emit(hyperdriveOutsideAction, {
-          cacheKey: `hyperdrive_outside_action:${call.file}:${call.line.toString()}:${call.callee}`,
-          detail: `\`${call.callee}(…)\` in ${call.exportName} (${call.file}:${call.line.toString()}) runs inside a ${call.kind} handler — Hyperdrive's \`ctx.sql\` is non-deterministic and non-reactive, so it is available only in actions. Move the external SQL into an \`action\` and project the result into a Lunora table if a query/mutation needs it.`,
-          metadata: { callee: call.callee, exportName: call.exportName, file: call.file, kind: call.kind, line: call.line }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Hyperdrive `ctx.sql` used outside an action"
-};
-
-export { hyperdriveOutsideAction as default };

package/dist/packem_shared/indexReferencesUnknownField-DH0_dbUY.mjs

@@ -1,36 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-import { t as tableColumnSet } from './helpers-DNCkMWZQ.mjs';
-
-const indexReferencesUnknownField = {
-  categories: ["SCHEMA"],
-  description: "An index references a column that is not declared on its table. The index can never match, and the typo would otherwise surface only at runtime.",
-  facing: "INTERNAL",
-  level: "ERROR",
-  name: "index_references_unknown_field",
-  remediation: "Fix the column name in the index declaration, or add the column to the table.",
-  run: (context) => {
-    const findings = [];
-    for (const table of context.schema.tables) {
-      const columns = tableColumnSet(table);
-      for (const index of table.indexes) {
-        for (const field of index.fields) {
-          if (columns.has(field)) {
-            continue;
-          }
-          findings.push(
-            emit(indexReferencesUnknownField, {
-              cacheKey: `index_references_unknown_field:${table.name}:${index.name}:${field}`,
-              detail: `Index "${index.name}" on table "${table.name}" references column "${field}", which is not declared on the table.`,
-              metadata: { field, index: index.name, indexKind: index.kind, table: table.name }
-            })
-          );
-        }
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Index references unknown field"
-};
-
-export { indexReferencesUnknownField as default };

package/dist/packem_shared/indexUtilization-B5DMQ3bI.mjs

@@ -1,45 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const HOT_SCAN_THRESHOLD = 25;
-const indexUtilization = {
-  categories: ["PERFORMANCE"],
-  description: "Recorded reads show an index the workload doesn't pay for: either a declared index no read ever used (dead overhead on every write) or a table read hot with no index at all (a repeated full scan that degrades as it grows).",
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "index_utilization",
-  remediation: "Drop a dead index so writes stop maintaining it; add an index covering the hot full-scanned table's read predicate so the read stops scanning every row.",
-  run: (context) => {
-    const findings = [];
-    for (const hit of context.indexHits ?? []) {
-      if (hit.reads > 0) {
-        continue;
-      }
-      findings.push(
-        emit(indexUtilization, {
-          cacheKey: `index_utilization:dead_index:${hit.table}:${hit.index}`,
-          detail: `Index "${hit.index}" on table "${hit.table}" has recorded no reads since its counter was created — it's dead overhead: every write maintains it and nothing reads through it.`,
-          metadata: { index: hit.index, kind: "dead_index", reads: hit.reads, table: hit.table }
-        })
-      );
-    }
-    for (const scan of context.tableScans ?? []) {
-      if (scan.scans < HOT_SCAN_THRESHOLD) {
-        continue;
-      }
-      findings.push(
-        emit(indexUtilization, {
-          cacheKey: `index_utilization:hot_scan:${scan.table}`,
-          detail: `Table "${scan.table}" has been full-scanned ${scan.scans.toString()} times (cumulative) with no index — a repeated full scan that degrades linearly as "${scan.table}" grows. Add an index covering the read predicate.`,
-          facing: "EXTERNAL",
-          level: "WARN",
-          metadata: { kind: "hot_scan", scans: scan.scans, table: scan.table }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "runtime",
-  title: "Index utilization"
-};
-
-export { indexUtilization as default };