@lunora/advisor 1.0.0-alpha.34 → 1.0.0-alpha.36

package/dist/packem_shared/sqlInjectionRisk-zwytYGLt.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const sqlInjectionRisk = {
-  categories: ["SECURITY"],
-  description: "A `ctx.sql` tagged-template interpolates an unparameterized string-building expression (concatenation or nested template) instead of a bound value — splicing raw text into the query and reopening SQL injection.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "sql_injection_risk",
-  remediation: "Pass the value through a bound placeholder so the driver parameterizes it — keep request input inside a `ctx.sql` placeholder instead of concatenating it into the query string. Never build SQL text from request input by hand.",
-  run: (context) => {
-    if (context.sqlInterpolations === void 0) {
-      return [];
-    }
-    return context.sqlInterpolations.map(
-      (interpolation) => emit(sqlInjectionRisk, {
-        cacheKey: `sql_injection_risk:${interpolation.file}:${interpolation.line.toString()}`,
-        detail: `\`ctx.sql\` in \`${interpolation.exportName}\` (${interpolation.file}:${interpolation.line.toString()}) interpolates a string-building expression instead of a bound value — a SQL-injection vector. Pass the value through a bound placeholder so the driver parameterizes it.`,
-        metadata: { exportName: interpolation.exportName, file: interpolation.file, line: interpolation.line }
-      })
-    );
-  },
-  source: "static",
-  title: "Possible SQL injection in ctx.sql interpolation"
-};
-
-export { sqlInjectionRisk as default };

package/dist/packem_shared/storageGenerateUploadUrlNoContentTypePin-Da4L9Ge8.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const storageGenerateUploadUrlNoContentTypePin = {
-  categories: ["SECURITY"],
-  description: "A `ctx.storage.generateUploadUrl(key, …)` call has no `contentType` pin, so the signed PUT URL it mints authorizes any content-type/size the client chooses — `upload()`'s `allowedContentTypes`/`maxSize` guards never run for a client-side PUT against this URL.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "storage_generate_upload_url_no_content_type_pin",
-  remediation: "Pass `contentType` to `ctx.storage.generateUploadUrl(key, { contentType })` so the signature only authorizes a PUT with that exact content-type. If the client's upload size/type also needs bounding, prefer `upload()`/`store()` (with `allowedContentTypes`/`maxSize`) over a client-side signed PUT.",
-  run: (context) => {
-    if (context.storageUploads === void 0) {
-      return [];
-    }
-    return context.storageUploads.filter((row) => row.method === "generateUploadUrl" && row.analyzable && !row.presentKeys.includes("contentType")).map(
-      (row) => emit(storageGenerateUploadUrlNoContentTypePin, {
-        cacheKey: `storage_generate_upload_url_no_content_type_pin:${row.file}:${row.line.toString()}`,
-        detail: `\`ctx.storage.generateUploadUrl\` in \`${row.exportName}\` (${row.file}:${row.line.toString()}) has no \`contentType\` pin — the signed PUT it mints accepts any type/size, minted client-side and bypassing \`upload()\`'s guards.`,
-        metadata: { exportName: row.exportName, file: row.file, line: row.line }
-      })
-    );
-  },
-  source: "static",
-  title: "generateUploadUrl signed PUT with no content-type pin"
-};
-
-export { storageGenerateUploadUrlNoContentTypePin as default };

package/dist/packem_shared/storageKeyFromUserArgs-B86elJgS.mjs

@@ -1,19 +0,0 @@
-import { m as makeArgumentDerivedSinkLint } from './argument-derived-sink-C1xTTqAt.mjs';
-
-const storageKeyFromUserArgs = makeArgumentDerivedSinkLint({
-  cacheKey: (access) => `storage_key_from_user_args:${access.file}:${access.line.toString()}`,
-  categories: ["SECURITY"],
-  description: "A `ctx.storage.*` call uses an R2 object key taken directly from the handler's `args` with no server-side scoping. The bucket methods key by the caller-supplied string, so any caller can read, overwrite, or delete another user's object — object-level IDOR.",
-  detail: (access) => `\`ctx.storage.*.${access.method}\` in \`${access.exportName}\` (${access.file}:${access.line.toString()}) uses an object key derived from \`args\` with no server-side scoping — any caller can read/overwrite/delete another user's object (IDOR). Prefix the key with a server-trusted identity (e.g. \`\${ctx.auth.userId}/…\`) or resolve the object through an owned record.`,
-  facing: "EXTERNAL",
-  getAccesses: (context) => context.storageKeyAccesses,
-  level: "ERROR",
-  metadata: (access) => {
-    return { exportName: access.exportName, file: access.file, line: access.line, method: access.method };
-  },
-  name: "storage_key_from_user_args",
-  remediation: `Prefix the object key with a server-trusted identity (e.g. \`\${ctx.auth.userId}/…\`) or resolve the object through a record the caller is known to own. Never pass request input straight through as an R2 object key.`,
-  title: "R2 object key taken directly from user args (IDOR)"
-});
-
-export { storageKeyFromUserArgs as default };

package/dist/packem_shared/storagePresignedUrlForPrivateContent-yGmb8uqz.mjs

@@ -1,47 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const SIGNER_METHODS = /* @__PURE__ */ new Set(["getPresignedUrl", "getSignedUrl"]);
-const NEAR_MAX_EXPIRES_THRESHOLD_SECONDS = 6 * 24 * 60 * 60;
-const isNativePresignedCall = (row) => row.method === "getPresignedUrl";
-const isNearExpiryCeiling = (row) => SIGNER_METHODS.has(row.method) && row.expiresInSeconds !== void 0 && row.expiresInSeconds >= NEAR_MAX_EXPIRES_THRESHOLD_SECONDS;
-const storagePresignedUrlForPrivateContent = {
-  categories: ["SECURITY"],
-  description: "`ctx.storage.getPresignedUrl(...)` mints a native S3 SigV4 URL that resolves directly against R2, bypassing the Worker's auth/RLS/rate-limit entirely — the wrong choice for private or policy-gated content. Either signer minting an `expiresInSeconds` near the shared 7-day ceiling also hands out a long-lived bearer credential.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "storage_presigned_url_for_private_content",
-  remediation: "For private/per-user/policy-gated content, use `getSignedUrl` (resolves back through the Worker, so your auth/RLS/rate-limit gates still run) instead of `getPresignedUrl`. Reserve `getPresignedUrl` for genuinely public or bulk content. On either signer, keep `expiresInSeconds` as short as the use case allows — well under the 7-day ceiling — rather than minting a near-maximum-lifetime URL.",
-  run: (context) => {
-    if (context.storageUploads === void 0) {
-      return [];
-    }
-    return context.storageUploads.filter((row) => isNativePresignedCall(row) || isNearExpiryCeiling(row)).map((row) => {
-      const native = isNativePresignedCall(row);
-      const nearCeiling = isNearExpiryCeiling(row);
-      const location = `\`${row.exportName}\` (${row.file}:${row.line.toString()})`;
-      let detail;
-      if (native && nearCeiling) {
-        detail = `\`ctx.storage.getPresignedUrl\` in ${location} mints a native S3 SigV4 URL — bypasses the Worker's auth/RLS/rate-limit entirely — with an \`expiresInSeconds\` of ${(row.expiresInSeconds ?? 0).toString()}s, near the 7-day signing ceiling.`;
-      } else if (native) {
-        detail = `\`ctx.storage.getPresignedUrl\` in ${location} mints a native S3 SigV4 URL that resolves directly against R2, bypassing the Worker's auth/RLS/rate-limit entirely. Use \`getSignedUrl\` for app-gated access to private content.`;
-      } else {
-        detail = `\`ctx.storage.${row.method}\` in ${location} requests an \`expiresInSeconds\` of ${(row.expiresInSeconds ?? 0).toString()}s, near the 7-day signing ceiling — a leaked link stays valid for almost a week.`;
-      }
-      return emit(storagePresignedUrlForPrivateContent, {
-        cacheKey: `storage_presigned_url_for_private_content:${row.file}:${row.line.toString()}`,
-        detail,
-        metadata: {
-          expiresInSeconds: row.expiresInSeconds,
-          exportName: row.exportName,
-          file: row.file,
-          line: row.line,
-          method: row.method
-        }
-      });
-    });
-  },
-  source: "static",
-  title: "Native presigned URL or near-max-TTL signed URL for private content"
-};
-
-export { storagePresignedUrlForPrivateContent as default };

package/dist/packem_shared/storageUploadWithoutContentTypeAllowlist-BV-gF1lT.mjs

@@ -1,27 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const UPLOAD_METHODS = /* @__PURE__ */ new Set(["store", "upload"]);
-const storageUploadWithoutContentTypeAllowlist = {
-  categories: ["SECURITY"],
-  description: "A `ctx.storage.upload`/`store` call has no `allowedContentTypes` allowlist, so an uploader can store any content-type — including `text/html` or `image/svg+xml` — which, served back from `publicBaseUrl`, is a stored-XSS vector against your own origin.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "storage_upload_without_content_type_allowlist",
-  remediation: 'Pass `allowedContentTypes: ["image/png", "image/jpeg", …]` to `ctx.storage.upload`/`store` so an uploaded object\'s `contentType` must match an approved list. Reject anything HTML/SVG/script-executable unless the app genuinely needs to serve it.',
-  run: (context) => {
-    if (context.storageUploads === void 0) {
-      return [];
-    }
-    return context.storageUploads.filter((row) => UPLOAD_METHODS.has(row.method) && row.analyzable && !row.presentKeys.includes("allowedContentTypes")).map(
-      (row) => emit(storageUploadWithoutContentTypeAllowlist, {
-        cacheKey: `storage_upload_without_content_type_allowlist:${row.file}:${row.line.toString()}`,
-        detail: `\`ctx.storage.${row.method}\` in \`${row.exportName}\` (${row.file}:${row.line.toString()}) has no \`allowedContentTypes\` allowlist — any content-type is accepted, including \`text/html\`/\`image/svg+xml\`, a stored-XSS risk if the object is served from \`publicBaseUrl\`.`,
-        metadata: { exportName: row.exportName, file: row.file, line: row.line, method: row.method }
-      })
-    );
-  },
-  source: "static",
-  title: "Storage upload with no content-type allowlist"
-};
-
-export { storageUploadWithoutContentTypeAllowlist as default };

package/dist/packem_shared/storageUploadWithoutMaxSize-DpxO59wU.mjs

@@ -1,27 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const UPLOAD_METHODS = /* @__PURE__ */ new Set(["store", "upload"]);
-const storageUploadWithoutMaxSize = {
-  categories: ["SECURITY"],
-  description: "A `ctx.storage.upload`/`store` call has no `maxSize` cap, so a caller can push an unbounded body straight into R2 through the Worker — unbounded storage/billing exhaustion, and for a streamed body, unbounded worker time.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "storage_upload_without_max_size",
-  remediation: "Pass a `maxSize` (bytes) to `ctx.storage.upload`/`store` sized to the largest legitimate object the app accepts. `ArrayBuffer`/`Blob` bodies are rejected up front when oversized; a `ReadableStream` body is aborted mid-transfer once the limit is exceeded.",
-  run: (context) => {
-    if (context.storageUploads === void 0) {
-      return [];
-    }
-    return context.storageUploads.filter((row) => UPLOAD_METHODS.has(row.method) && row.analyzable && !row.presentKeys.includes("maxSize")).map(
-      (row) => emit(storageUploadWithoutMaxSize, {
-        cacheKey: `storage_upload_without_max_size:${row.file}:${row.line.toString()}`,
-        detail: `\`ctx.storage.${row.method}\` in \`${row.exportName}\` (${row.file}:${row.line.toString()}) has no \`maxSize\` cap — a caller can push an unbounded body into R2, exhausting storage/billing.`,
-        metadata: { exportName: row.exportName, file: row.file, line: row.line, method: row.method }
-      })
-    );
-  },
-  source: "static",
-  title: "Storage upload with no size cap"
-};
-
-export { storageUploadWithoutMaxSize as default };

package/dist/packem_shared/tableWithoutInsert-CbbaYIP4.mjs

@@ -1,34 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const tableWithoutInsert = {
-  categories: ["SCHEMA"],
-  description: 'No function inserts into this table via `ctx.db.insert("<table>", …)`. It may be read-only by design (seeded by a migration, replicated, or written through a path the advisor can\'t see) — or it may be dead schema.',
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "table_without_insert",
-  remediation: 'If the table should be writable, add a mutation that calls `ctx.db.insert("<table>", …)`. If it is read-only or seeded elsewhere, this advisory can be ignored.',
-  run: (context) => {
-    if (context.inserts === void 0) {
-      return [];
-    }
-    const insertedTables = new Set(context.inserts.filter((write) => write.table !== "").map((write) => write.table));
-    const findings = [];
-    for (const table of context.schema.tables) {
-      if (insertedTables.has(table.name) || table.externallyManaged === true) {
-        continue;
-      }
-      findings.push(
-        emit(tableWithoutInsert, {
-          cacheKey: `table_without_insert:${table.name}`,
-          detail: `No function calls \`ctx.db.insert("${table.name}", …)\` — table "${table.name}" has no discovered insert path.`,
-          metadata: { table: table.name }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Table has no insert path"
-};
-
-export { tableWithoutInsert as default };

package/dist/packem_shared/ttlFieldNotTimestamp-Dpaj63Z6.mjs

@@ -1,36 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const TIME_KINDS = /* @__PURE__ */ new Set(["date", "number", "timestamp"]);
-const ttlFieldNotTimestamp = {
-  categories: ["SCHEMA"],
-  description: "A `.ttl(field)` policy points at a column that is not an epoch-millisecond timestamp, so the alarm sweep's `field < now` comparison can't decide expiry correctly.",
-  facing: "INTERNAL",
-  level: "ERROR",
-  name: "ttl_field_not_timestamp",
-  remediation: "Point `.ttl(field)` at a `v.timestamp()` / `v.date()` / `v.number()` (epoch-ms) column, or add such a column.",
-  run: (context) => {
-    const findings = [];
-    for (const table of context.schema.tables) {
-      const { ttl } = table;
-      if (!ttl) {
-        continue;
-      }
-      const kind = table.columnKinds?.[ttl.field];
-      if (kind === void 0 || TIME_KINDS.has(kind)) {
-        continue;
-      }
-      findings.push(
-        emit(ttlFieldNotTimestamp, {
-          cacheKey: `ttl_field_not_timestamp:${table.name}:${ttl.field}`,
-          detail: `Table "${table.name}" declares \`.ttl("${ttl.field}")\`, but "${ttl.field}" is a ${kind} column, not an epoch-millisecond timestamp.`,
-          metadata: { field: ttl.field, kind, table: table.name }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "TTL field is not a timestamp"
-};
-
-export { ttlFieldNotTimestamp as default };

package/dist/packem_shared/unboundedStringArgument-DThg2-wt.mjs

@@ -1,32 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const unboundedStringArgument = {
-  categories: ["SECURITY"],
-  description: "A public `v.string()` argument has no maximum-length bound. An unbounded string lets a client submit arbitrarily large input — abusing storage and CPU on every request that processes it.",
-  facing: "EXTERNAL",
-  level: "INFO",
-  name: "unbounded_string_arg",
-  remediation: "Add a max-length bound via `.check(...)` / `.meta({ maxLength })` on the string validator (e.g. cap a name at 256, a body at a few KB). Size the cap to the field's real-world maximum.",
-  run: (context) => {
-    if (context.argValidators === void 0) {
-      return [];
-    }
-    const findings = [];
-    for (const procedure of context.argValidators) {
-      for (const argument of procedure.unboundedStringArgs) {
-        findings.push(
-          emit(unboundedStringArgument, {
-            cacheKey: `unbounded_string_arg:${procedure.file}:${procedure.exportName}:${argument}`,
-            detail: `Arg \`${argument}\` of public procedure \`${procedure.exportName}\` (${procedure.file}:${procedure.line.toString()}) is an unbounded \`v.string()\`. Add a max-length bound to cap payload size.`,
-            metadata: { argument, exportName: procedure.exportName, file: procedure.file, line: procedure.line }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Public string argument has no length bound"
-};
-
-export { unboundedStringArgument as default };

package/dist/packem_shared/unindexedForeignKey-BgJbKyqK.mjs

@@ -1,45 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-import { l as leadingIndexedColumns, P as PRIMARY_KEY, s as suggestIndexName } from './fk-index-IUK1ukgs.mjs';
-
-const unindexedForeignKey = {
-  categories: ["PERFORMANCE"],
-  description: "A foreign-key column declared by a `one` relation has no index leading with it. Reads that filter or join on the column full-scan the table, which gets linearly slower as rows accumulate.",
-  facing: "EXTERNAL",
-  level: "INFO",
-  name: "unindexed_foreign_key",
-  remediation: 'Add a secondary index leading with the FK column, e.g. `.index("byAuthorId", ["authorId"])`.',
-  run: (context) => {
-    const findings = [];
-    for (const table of context.schema.tables) {
-      const indexed = leadingIndexedColumns(table);
-      for (const relation of table.relations) {
-        if (relation.kind !== "one") {
-          continue;
-        }
-        const fkColumn = relation.field;
-        if (fkColumn === PRIMARY_KEY || indexed.has(fkColumn)) {
-          continue;
-        }
-        const suggestedIndex = suggestIndexName(fkColumn);
-        findings.push(
-          emit(unindexedForeignKey, {
-            cacheKey: `unindexed_foreign_key:${table.name}:${fkColumn}`,
-            detail: `Relation "${relation.name}" on table "${table.name}" references "${relation.table}" via column "${fkColumn}", which is not the leading column of any index. Reads filtering or joining on "${fkColumn}" full-scan "${table.name}".`,
-            metadata: {
-              fkColumn,
-              references: { column: relation.references, table: relation.table },
-              relation: relation.name,
-              suggestedIndex: { fields: [fkColumn], name: suggestedIndex },
-              table: table.name
-            }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Unindexed foreign key"
-};
-
-export { unindexedForeignKey as default };

package/dist/packem_shared/unindexedRelationTarget-D6eyj6Xx.mjs

@@ -1,53 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-import { P as PRIMARY_KEY, l as leadingIndexedColumns, s as suggestIndexName } from './fk-index-IUK1ukgs.mjs';
-
-const unindexedRelationTarget = {
-  categories: ["PERFORMANCE"],
-  description: "A `many` relation's foreign-key column on the target table has no index leading with it. Relation predicates (`some`/`none`/`every`) and `with:` child reads filter the target on that column, full-scanning it as rows accumulate.",
-  facing: "EXTERNAL",
-  level: "INFO",
-  name: "unindexed_relation_target",
-  remediation: 'Add a secondary index on the target table leading with the FK column, e.g. `.index("byAuthorId", ["authorId"])`.',
-  run: (context) => {
-    const findings = [];
-    const tablesByName = new Map(context.schema.tables.map((table) => [table.name, table]));
-    for (const table of context.schema.tables) {
-      for (const relation of table.relations) {
-        if (relation.kind !== "many") {
-          continue;
-        }
-        const target = tablesByName.get(relation.table);
-        if (target === void 0) {
-          continue;
-        }
-        const fkColumn = relation.field;
-        if (fkColumn === PRIMARY_KEY) {
-          continue;
-        }
-        const coveredByForeignKeyLint = target.relations.some((targetRelation) => targetRelation.kind === "one" && targetRelation.field === fkColumn);
-        if (coveredByForeignKeyLint || leadingIndexedColumns(target).has(fkColumn)) {
-          continue;
-        }
-        const suggestedIndex = suggestIndexName(fkColumn);
-        findings.push(
-          emit(unindexedRelationTarget, {
-            cacheKey: `unindexed_relation_target:${relation.table}:${fkColumn}`,
-            detail: `Relation "${relation.name}" on table "${table.name}" is a to-many over "${relation.table}" via its column "${fkColumn}", which is not the leading column of any index on "${relation.table}". Relation predicates (\`some\`/\`none\`/\`every\`) and \`with:\` reads of "${relation.name}" full-scan "${relation.table}".`,
-            metadata: {
-              fkColumn,
-              references: { column: relation.references, table: table.name },
-              relation: relation.name,
-              suggestedIndex: { fields: [fkColumn], name: suggestedIndex },
-              table: relation.table
-            }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Unindexed relation target"
-};
-
-export { unindexedRelationTarget as default };

package/dist/packem_shared/userCreatingMutationWithoutCaptcha-2DZtWIPb.mjs

@@ -1,42 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-import { i as isPublicWrite } from './helpers-BySnKhVB.mjs';
-
-const userCreatingMutationWithoutCaptcha = {
-  categories: ["SECURITY"],
-  description: "A public `mutation`/`action` that creates a user/session or sends mail has no CAPTCHA / bot check. Account-creating and mail-sending endpoints are prime automated-abuse targets (credential stuffing, mailbox flooding, disposable-account farming).",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "user_creating_mutation_without_captcha",
-  remediation: "Add a server-verified human check: `.use(verifyTurnstile({ secret, token }))` from `@lunora/auth`, or wrap it with `.use(protectPublic({ rateLimit, captcha }))` from `@lunora/server`. Pair with a rate limit for defense in depth.",
-  run: (context) => {
-    if (context.procedureProtections === void 0) {
-      return [];
-    }
-    const findings = [];
-    for (const procedure of context.procedureProtections) {
-      const sensitive = procedure.writesUserTable || procedure.callsMail;
-      if (!isPublicWrite(procedure) || !sensitive || procedure.usesCaptcha) {
-        continue;
-      }
-      const reason = procedure.writesUserTable ? "writes a user/session table" : "sends mail";
-      findings.push(
-        emit(userCreatingMutationWithoutCaptcha, {
-          cacheKey: `user_creating_mutation_without_captcha:${procedure.file}:${procedure.exportName}`,
-          detail: `Public ${procedure.kind} \`${procedure.exportName}\` (${procedure.file}) ${reason} but has no CAPTCHA check. Add \`.use(verifyTurnstile(...))\` or \`.use(protectPublic({ captcha }))\`.`,
-          metadata: {
-            callsMail: procedure.callsMail,
-            exportName: procedure.exportName,
-            file: procedure.file,
-            kind: procedure.kind,
-            writesUserTable: procedure.writesUserTable
-          }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Account-creating / mail-sending write without a CAPTCHA"
-};
-
-export { userCreatingMutationWithoutCaptcha as default };

package/dist/packem_shared/vectorsNamespaceFromUserInput-CQhr5bVn.mjs

@@ -1,19 +0,0 @@
-import { m as makeArgumentDerivedSinkLint } from './argument-derived-sink-C1xTTqAt.mjs';
-
-const vectorsNamespaceFromUserInput = makeArgumentDerivedSinkLint({
-  cacheKey: (access) => `vectors_namespace_from_user_input:${access.file}:${access.line.toString()}`,
-  categories: ["SECURITY"],
-  description: "A `ctx.vectors.query`/`upsert`/`upsertMany` call uses a `namespace` derived from the handler's `args` with no server-side scoping. A Vectorize namespace partitions one index into isolated sub-collections, so an unscoped namespace lets any caller read or poison another tenant's vectors.",
-  detail: (access) => `\`ctx.vectors.${access.method}\` in \`${access.exportName}\` (${access.file}:${access.line.toString()}) uses a Vectorize namespace derived from \`args\` with no server-side scoping — any caller can read or poison another tenant's vectors. Derive the namespace from a server-trusted identity (e.g. \`\${ctx.auth.orgId}\`), never from \`args\`.`,
-  facing: "EXTERNAL",
-  getAccesses: (context) => context.vectorNamespaceAccesses,
-  level: "WARN",
-  metadata: (access) => {
-    return { exportName: access.exportName, file: access.file, line: access.line, method: access.method };
-  },
-  name: "vectors_namespace_from_user_input",
-  remediation: `Derive the \`namespace\` from a server-trusted identity (e.g. \`\${ctx.auth.orgId}\`), never from \`args\`.`,
-  title: "Vectorize namespace derived from unscoped user input"
-});
-
-export { vectorsNamespaceFromUserInput as default };

package/dist/packem_shared/workflowDuplicateStepName-ioBxPBCy.mjs

@@ -1,48 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const workflowDuplicateStepName = {
-  categories: ["SCHEMA"],
-  description: "Two durable steps in this workflow share a name. Cloudflare memoizes a step by its name, so on replay the second call returns the first step's cached result instead of running its body — silently skipping the work without an error.",
-  facing: "INTERNAL",
-  level: "ERROR",
-  // eslint-disable-next-line no-secrets/no-secrets -- the lint's rule id, not a credential
-  name: "workflow_duplicate_step_name",
-  remediation: "Give every `step.do` / `step.sleep` / `step.sleepUntil` / `step.waitForEvent` call in the workflow a unique name. If a step legitimately repeats (e.g. a loop), make the name distinct per iteration by interpolating the item id into the step name.",
-  run: (context) => {
-    if (context.workflows === void 0) {
-      return [];
-    }
-    const findings = [];
-    for (const workflow of context.workflows) {
-      const { steps } = workflow;
-      if (steps === void 0 || steps.length === 0) {
-        continue;
-      }
-      const firstLineByName = /* @__PURE__ */ new Map();
-      const reported = /* @__PURE__ */ new Set();
-      for (const step of steps) {
-        const firstLine = firstLineByName.get(step.name);
-        if (firstLine === void 0) {
-          firstLineByName.set(step.name, step.line);
-          continue;
-        }
-        if (reported.has(step.name)) {
-          continue;
-        }
-        reported.add(step.name);
-        findings.push(
-          emit(workflowDuplicateStepName, {
-            cacheKey: `workflow_duplicate_step_name:${workflow.exportName}:${step.name}`,
-            detail: `Workflow "${workflow.exportName}" reuses the durable step name "${step.name}" (first at line ${String(firstLine)}, again at line ${String(step.line)}). The second call returns the first's cached result instead of running.`,
-            metadata: { firstLine, line: step.line, stepName: step.name, workflow: workflow.exportName }
-          })
-        );
-      }
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Duplicate durable step name in workflow"
-};
-
-export { workflowDuplicateStepName as default };

package/dist/packem_shared/workflowUnknownTarget-Cdd7WhKQ.mjs

@@ -1,34 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const workflowUnknownTarget = {
-  categories: ["SCHEMA"],
-  description: 'A `ctx.workflows.get("<name>")` call references a workflow that is not declared by any `defineWorkflow` export in `lunora/workflows.ts`. The name is a typo or points at a removed/renamed workflow — the call throws at runtime.',
-  facing: "INTERNAL",
-  level: "ERROR",
-  name: "workflow_unknown_target",
-  remediation: 'Fix the workflow name in the `ctx.workflows.get("…")` call, or add the missing `defineWorkflow` export to `lunora/workflows.ts`.',
-  run: (context) => {
-    if (context.workflows === void 0 || context.workflowCalls === void 0) {
-      return [];
-    }
-    const declared = new Set(context.workflows.map((workflow) => workflow.exportName));
-    const findings = [];
-    for (const call of context.workflowCalls) {
-      if (call.workflow === "" || declared.has(call.workflow)) {
-        continue;
-      }
-      findings.push(
-        emit(workflowUnknownTarget, {
-          cacheKey: `workflow_unknown_target:${call.file}:${call.exportName}:${call.workflow}`,
-          detail: `\`ctx.workflows.get("${call.workflow}")\` in "${call.exportName}" (${call.file}) references workflow "${call.workflow}", which is not declared in lunora/workflows.ts.`,
-          metadata: { exportName: call.exportName, file: call.file, line: call.line, workflow: call.workflow }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Workflow call references unknown workflow"
-};
-
-export { workflowUnknownTarget as default };

package/dist/packem_shared/workflowUnused-D0jHxdz9.mjs

@@ -1,38 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const workflowUnused = {
-  categories: ["SCHEMA"],
-  description: 'No function starts this workflow via `ctx.workflows.get("<name>")`. It may be triggered through a path the advisor can\'t see (the Cloudflare API, a wrangler invocation, a cross-service binding) — or it may be dead code that still deploys as a billable WorkflowEntrypoint.',
-  facing: "INTERNAL",
-  level: "INFO",
-  name: "workflow_unused",
-  remediation: 'If the workflow should be triggered in-app, start it from a mutation/action with `ctx.workflows.get("<name>").create({ params })`. If it is started externally or is no longer needed, this advisory can be ignored (or remove the `defineWorkflow` export).',
-  run: (context) => {
-    if (context.workflows === void 0) {
-      return [];
-    }
-    const calls = context.workflowCalls ?? [];
-    if (calls.some((call) => call.workflow === "")) {
-      return [];
-    }
-    const started = new Set(calls.map((call) => call.workflow));
-    const findings = [];
-    for (const workflow of context.workflows) {
-      if (started.has(workflow.exportName)) {
-        continue;
-      }
-      findings.push(
-        emit(workflowUnused, {
-          cacheKey: `workflow_unused:${workflow.exportName}`,
-          detail: `No function calls \`ctx.workflows.get("${workflow.exportName}")\` — workflow "${workflow.exportName}" is declared but never started in app code.`,
-          metadata: { workflow: workflow.exportName }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Workflow is never started"
-};
-
-export { workflowUnused as default };