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

package/dist/packem_shared/actionFetchSsrf-wbmYgzmz.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const actionFetchSsrf = {
-  categories: ["SECURITY"],
-  description: "An action's `ctx.fetch(url)` fetches a URL derived from the handler's `args`. `ctx.fetch` applies no host allowlist, so request-controlled URLs let a caller reach cloud metadata endpoints or internal services — server-side request forgery.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "action_fetch_ssrf",
-  remediation: "Validate the URL against an allowlist of expected hosts before fetching, and reject private, loopback, and link-local addresses (notably `169.254.169.254`). Never pass request input straight to `ctx.fetch`.",
-  run: (context) => {
-    if (context.argumentDerivedFetches === void 0) {
-      return [];
-    }
-    return context.argumentDerivedFetches.map(
-      (fetchCall) => emit(actionFetchSsrf, {
-        cacheKey: `action_fetch_ssrf:${fetchCall.file}:${fetchCall.line.toString()}`,
-        detail: `\`ctx.fetch\` in \`${fetchCall.exportName}\` (${fetchCall.file}:${fetchCall.line.toString()}) fetches a URL derived from \`args\` — a server-side request forgery vector. Validate the URL against a host allowlist and reject private/link-local targets before fetching.`,
-        metadata: { exportName: fetchCall.exportName, file: fetchCall.file, line: fetchCall.line }
-      })
-    );
-  },
-  source: "static",
-  title: "Possible SSRF from arg-derived ctx.fetch URL"
-};
-
-export { actionFetchSsrf as default };

package/dist/packem_shared/adminRouteWithoutGuard-UUGBkAjU.mjs

@@ -1,33 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const adminRouteWithoutGuard = {
-  categories: ["SECURITY"],
-  description: "An `httpRoute` on an admin/privileged path has no visible auth/admin guard. REST routes aren't covered by RLS, so an unguarded `/admin/*` route is callable by anyone who reaches the URL.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "admin_route_without_guard",
-  remediation: "Assert an authenticated, authorized caller at the top of the handler — check `ctx.auth` / `getSession(...)`, or a `requireAdmin`-style guard — and reject (401/403) before doing privileged work. For machine callers, verify a secret with a timing-safe compare.",
-  run: (context) => {
-    if (context.adminRoutes === void 0) {
-      return [];
-    }
-    const findings = [];
-    for (const route of context.adminRoutes) {
-      if (route.usesGuard) {
-        continue;
-      }
-      findings.push(
-        emit(adminRouteWithoutGuard, {
-          cacheKey: `admin_route_without_guard:${route.file}:${route.method}:${route.path}`,
-          detail: `Route \`${route.method} ${route.path}\` (\`${route.exportName}\` in ${route.file}) is on an admin/privileged path but its handler shows no auth/admin guard. Assert an authorized caller before doing privileged work.`,
-          metadata: { exportName: route.exportName, file: route.file, method: route.method, path: route.path }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Admin route without an auth guard"
-};
-
-export { adminRouteWithoutGuard as default };

package/dist/packem_shared/aiRawRunEscapeHatch-C29jd32J.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const aiRawRunEscapeHatch = {
-  categories: ["SECURITY"],
-  description: "A `ctx.ai.run(model, …)` call selects its model from the handler's `args` with no server-side scoping. `ctx.ai.run` is the raw Workers AI binding passthrough, so an arg-derived model id lets any caller pick an arbitrary model — bypassing the typed `ctx.ai.model(...)` + AI-SDK layer's cap/schema.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "ai_raw_run_escape_hatch",
-  remediation: `Select the model from a fixed server-side allowlist — never from \`args\`. Prefer the typed \`ctx.ai.model(...)\` + \`generateText\`/\`streamText\` path with an output cap over the raw \`ctx.ai.run\` escape hatch.`,
-  run: (context) => {
-    if (context.aiRawRuns === void 0) {
-      return [];
-    }
-    return context.aiRawRuns.map(
-      (access) => emit(aiRawRunEscapeHatch, {
-        cacheKey: `ai_raw_run_escape_hatch:${access.file}:${access.line.toString()}`,
-        detail: `\`ctx.ai.run\` in \`${access.exportName}\` (${access.file}:${access.line.toString()}) selects its model from \`args\` with no server-side scoping — any caller can pick an arbitrary model, bypassing the typed AI-SDK layer's cap/schema. Select the model from a fixed server-side allowlist instead.`,
-        metadata: { exportName: access.exportName, file: access.file, line: access.line }
-      })
-    );
-  },
-  source: "static",
-  title: "Possible arbitrary model selection from arg-derived ctx.ai.run"
-};
-
-export { aiRawRunEscapeHatch as default };

package/dist/packem_shared/aiToolSideEffectPromptInjection-BtD3alqB.mjs

@@ -1,33 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const aiToolSideEffectPromptInjection = {
-  categories: ["SECURITY"],
-  description: "A `generateText` / `streamText` call whose prompt/messages carry user-supplied text and whose model-callable `tools` perform a privileged side effect (DB write, `ctx.run` dispatch, or outbound send). An injected instruction in the user text can steer the model into firing that action — the confused-deputy prompt-injection hazard.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "ai_tool_side_effect_prompt_injection",
-  remediation: "Don't let a model with user-derived input directly trigger a privileged action. Have the tool return a proposal the server validates and authorizes before executing, gate the side effect behind an explicit human/step confirmation, or keep side-effecting tools out of any generation whose prompt includes untrusted input.",
-  run: (context) => {
-    if (context.aiToolSideEffects === void 0) {
-      return [];
-    }
-    return context.aiToolSideEffects.filter((row) => row.userInputDerived).map((row) => {
-      const location = `\`${row.exportName}\` (${row.file}:${row.line.toString()})`;
-      return emit(aiToolSideEffectPromptInjection, {
-        cacheKey: `ai_tool_side_effect_prompt_injection:${row.file}:${row.line.toString()}`,
-        detail: `\`${row.method}\` in ${location} feeds user-derived input to a model whose tools reach \`${row.sideEffect}\`. An injected instruction can steer the model into firing that side effect.`,
-        metadata: {
-          exportName: row.exportName,
-          file: row.file,
-          line: row.line,
-          method: row.method,
-          sideEffect: row.sideEffect
-        }
-      });
-    });
-  },
-  source: "static",
-  title: "AI tool side effect reachable via prompt injection"
-};
-
-export { aiToolSideEffectPromptInjection as default };

package/dist/packem_shared/aiUnboundedGenerationPublic-CbAcSxLB.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const aiUnboundedGenerationPublic = {
-  categories: ["SECURITY"],
-  description: "A public procedure runs an AI generation (`generateText`/`streamText`/`generateObject`/`streamObject`) with no `maxOutputTokens` bound. Generation bills per output token, so an anonymous caller can request arbitrarily long completions in a loop — a denial-of-wallet vector that also ties up worker time on long streams.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "ai_unbounded_generation_public",
-  remediation: "Cap the completion with `maxOutputTokens` in the generation config, and rate-limit the public entry point (`.use(rateLimit(...))`). For expensive models, prefer running generation from an internal, authenticated path rather than exposing it directly to anonymous callers.",
-  run: (context) => {
-    if (context.procedureProtections === void 0) {
-      return [];
-    }
-    return context.procedureProtections.filter((procedure) => procedure.unboundedAiGeneration && procedure.visibility === "public").map(
-      (procedure) => emit(aiUnboundedGenerationPublic, {
-        cacheKey: `ai_unbounded_generation_public:${procedure.file}:${procedure.exportName}`,
-        detail: `\`${procedure.exportName}\` (${procedure.file}) is public and runs an AI generation with no \`maxOutputTokens\` bound — an anonymous caller can drive unbounded, billable completions in a loop. Add a \`maxOutputTokens\` cap and rate-limit the entry point.`,
-        metadata: { exportName: procedure.exportName, file: procedure.file, kind: procedure.kind }
-      })
-    );
-  },
-  source: "static",
-  title: "Public procedure runs unbounded AI generation (no maxOutputTokens)"
-};
-
-export { aiUnboundedGenerationPublic as default };

package/dist/packem_shared/allowUnauthenticatedShardAccessEnabled-BcASq-jP.mjs

@@ -1,30 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const allowUnauthenticatedShardAccessEnabled = {
-  categories: ["SECURITY"],
-  description: "`.extend(() => ({ allowUnauthenticatedShardAccess: true }))` disables the fail-closed default that denies an unauthenticated shard lookup. Combined with a schema that doesn't enforce `.rls(\"required\")` everywhere (or that leaves a table `.public()`), an unauthenticated caller can shard-hop into another tenant's rows with no row-security guard behind the door.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "allow_unauthenticated_shard_access_enabled",
-  remediation: "Prefer `authorizeShard` / `authorizeFanOut` (which take precedence over `allowUnauthenticatedShardAccess` and let you allow specific unauthenticated cases) over the blanket opt-out. If the app genuinely needs open shard access, enforce `.rls(\"required\")` on the schema with no `.public()` tables so a missing identity still can't read another tenant's rows.",
-  run: (context) => {
-    if (context.configCalls === void 0) {
-      return [];
-    }
-    const hasRlsGap = context.schema.rlsMode !== "required" || context.schema.tables.some((table) => table.isPublic);
-    if (!hasRlsGap) {
-      return [];
-    }
-    return context.configCalls.filter((call) => call.callee === "extend" && call.trueKeys.includes("allowUnauthenticatedShardAccess")).map(
-      (call) => emit(allowUnauthenticatedShardAccessEnabled, {
-        cacheKey: `allow_unauthenticated_shard_access_enabled:${call.file}:${call.line.toString()}`,
-        detail: `\`.extend(...)\` in ${call.file}:${call.line.toString()} sets \`allowUnauthenticatedShardAccess: true\`, and the schema has an RLS gap (no \`.rls("required")\`, or a \`.public()\` table) — an unauthenticated caller can shard-hop into another tenant's rows with no row-security guard behind the door.`,
-        metadata: { callee: call.callee, file: call.file, line: call.line }
-      })
-    );
-  },
-  source: "static",
-  title: "Unauthenticated shard access enabled on an RLS-gapped schema"
-};
-
-export { allowUnauthenticatedShardAccessEnabled as default };

package/dist/packem_shared/argument-derived-sink-C1xTTqAt.mjs

@@ -1,30 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const makeArgumentDerivedSinkLint = (config) => {
-  const lint = {
-    categories: config.categories,
-    description: config.description,
-    facing: config.facing,
-    level: config.level,
-    name: config.name,
-    remediation: config.remediation,
-    run: (context) => {
-      const accesses = config.getAccesses(context);
-      if (accesses === void 0 || config.suppressWhen?.(context) === true) {
-        return [];
-      }
-      return accesses.map(
-        (access) => emit(lint, {
-          cacheKey: config.cacheKey(access),
-          detail: config.detail(access),
-          metadata: config.metadata(access)
-        })
-      );
-    },
-    source: "static",
-    title: config.title
-  };
-  return lint;
-};
-
-export { makeArgumentDerivedSinkLint as m };

package/dist/packem_shared/authApiCallWithoutHeaders-BeJhCZaf.mjs

@@ -1,38 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authApiCallWithoutHeaders = {
-  categories: ["SECURITY"],
-  description: "A `ctx.authApi.<method>(...)` call omits `headers` — better-auth skips session authorization and runs the call with full server-to-server privileges, regardless of the caller's identity.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "auth_api_call_without_headers",
-  remediation: "Pass the inbound `headers` from the incoming request into every `ctx.authApi.*` call: `ctx.authApi.<method>({ body, headers: request.headers })`. See the `withAuthPlugins` middleware doc for details.",
-  run: (context) => {
-    if (context.authApiCalls === void 0) {
-      return [];
-    }
-    const findings = [];
-    const occurrenceCount = /* @__PURE__ */ new Map();
-    for (const call of context.authApiCalls) {
-      if (call.hasHeaders) {
-        continue;
-      }
-      const baseKey = `${call.file}:${call.line.toString()}:${call.method}`;
-      const occurrence = (occurrenceCount.get(baseKey) ?? 0) + 1;
-      occurrenceCount.set(baseKey, occurrence);
-      const occurrenceSuffix = occurrence > 1 ? `:${occurrence.toString()}` : "";
-      findings.push(
-        emit(authApiCallWithoutHeaders, {
-          cacheKey: `auth_api_call_without_headers:${baseKey}${occurrenceSuffix}`,
-          detail: `\`ctx.authApi.${call.method || "<method>"}(…)\` in ${call.exportName} (${call.file}:${call.line.toString()}) is called without \`headers\` — better-auth skips session authorization, so this runs with full privileges. Pass the inbound \`headers\`.`,
-          metadata: { exportName: call.exportName, file: call.file, line: call.line, method: call.method }
-        })
-      );
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Privileged ctx.authApi call missing headers"
-};
-
-export { authApiCallWithoutHeaders as default };

package/dist/packem_shared/authCsrfCheckDisabled-DCf9FSoD.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authCsrfCheckDisabled = {
-  categories: ["SECURITY"],
-  description: "A `createAuth({...})` call sets `advanced.disableCSRFCheck: true`, turning off better-auth's origin validation for state-changing auth requests — a cross-site request riding the ambient auth cookie is processed like a same-origin one.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "auth_csrf_check_disabled",
-  remediation: "Remove `advanced.disableCSRFCheck: true` from `createAuth({...})` and rely on `trustedOrigins` for origin validation instead of disabling the check.",
-  run: (context) => {
-    if (context.authConfigs === void 0) {
-      return [];
-    }
-    return context.authConfigs.filter((config) => config.analyzable && config.disableCsrfCheck).map(
-      (config) => emit(authCsrfCheckDisabled, {
-        cacheKey: `auth_csrf_check_disabled:${config.file}:${config.line.toString()}`,
-        detail: `\`createAuth\` in \`${config.exportName}\` (${config.file}:${config.line.toString()}) sets \`advanced.disableCSRFCheck: true\`, turning off origin validation for state-changing auth requests. Remove the flag and rely on \`trustedOrigins\` instead.`,
-        metadata: { exportName: config.exportName, file: config.file, line: config.line }
-      })
-    );
-  },
-  source: "static",
-  title: "createAuth CSRF check disabled"
-};
-
-export { authCsrfCheckDisabled as default };

package/dist/packem_shared/authEmailVerificationDisabled-Dk-Tc5oU.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authEmailVerificationDisabled = {
-  categories: ["SECURITY"],
-  description: "A `createAuth({...})` call enables `emailAndPassword` with no `requireEmailVerification: true`. better-auth defaults email verification off, so an account is usable before the caller has proven ownership of the email address.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "auth_email_verification_disabled",
-  remediation: "Set `emailAndPassword.requireEmailVerification: true` on `createAuth({...})` so a new account can't act until its email address is verified.",
-  run: (context) => {
-    if (context.authConfigs === void 0) {
-      return [];
-    }
-    return context.authConfigs.filter((config) => config.analyzable && config.emailPasswordEnabled && !config.requireEmailVerification).map(
-      (config) => emit(authEmailVerificationDisabled, {
-        cacheKey: `auth_email_verification_disabled:${config.file}:${config.line.toString()}`,
-        detail: `\`createAuth\` in \`${config.exportName}\` (${config.file}:${config.line.toString()}) enables \`emailAndPassword\` with no \`requireEmailVerification: true\`, so an account is usable before its email is proven. Set \`emailAndPassword.requireEmailVerification: true\`.`,
-        metadata: { exportName: config.exportName, file: config.file, line: config.line }
-      })
-    );
-  },
-  source: "static",
-  title: "createAuth email verification disabled"
-};
-
-export { authEmailVerificationDisabled as default };

package/dist/packem_shared/authSecureCookiesDisabled-osJrHW9Y.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authSecureCookiesDisabled = {
-  categories: ["SECURITY"],
-  description: "A `createAuth({...})` call sets `advanced.useSecureCookies: false`, overriding Lunora's secure-by-default posture — the session cookie ships without `Secure` even on an HTTPS deployment, so it can be sent over a plaintext connection.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "auth_secure_cookies_disabled",
-  remediation: "Remove `advanced.useSecureCookies: false` from `createAuth({...})` — let Lunora's secure-by-default posture set the `Secure` cookie attribute for an HTTPS deployment.",
-  run: (context) => {
-    if (context.authConfigs === void 0) {
-      return [];
-    }
-    return context.authConfigs.filter((config) => config.analyzable && config.secureCookiesDisabled).map(
-      (config) => emit(authSecureCookiesDisabled, {
-        cacheKey: `auth_secure_cookies_disabled:${config.file}:${config.line.toString()}`,
-        detail: `\`createAuth\` in \`${config.exportName}\` (${config.file}:${config.line.toString()}) sets \`advanced.useSecureCookies: false\`, so the session cookie ships without \`Secure\` even on an HTTPS deployment. Remove the override and let Lunora's secure-by-default posture apply.`,
-        metadata: { exportName: config.exportName, file: config.file, line: config.line }
-      })
-    );
-  },
-  source: "static",
-  title: "createAuth secure cookies disabled"
-};
-
-export { authSecureCookiesDisabled as default };

package/dist/packem_shared/authSessionFreshageZero-CjufCc_Q.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authSessionFreshageZero = {
-  categories: ["SECURITY"],
-  description: "A `createAuth({...})` call sets `session.freshAge: 0`, disabling better-auth's recent-reauth check for sensitive operations — a long-lived stolen session can perform them without proving the caller still controls the credentials.",
-  facing: "EXTERNAL",
-  level: "WARN",
-  name: "auth_session_freshage_zero",
-  remediation: "Remove `session.freshAge: 0` from `createAuth({...})` (or set it to a real window) so sensitive operations require a recently re-authenticated session.",
-  run: (context) => {
-    if (context.authConfigs === void 0) {
-      return [];
-    }
-    return context.authConfigs.filter((config) => config.analyzable && config.sessionFreshAgeZero).map(
-      (config) => emit(authSessionFreshageZero, {
-        cacheKey: `auth_session_freshage_zero:${config.file}:${config.line.toString()}`,
-        detail: `\`createAuth\` in \`${config.exportName}\` (${config.file}:${config.line.toString()}) sets \`session.freshAge: 0\`, disabling the recent-reauth check for sensitive operations. Remove the override or set a real window.`,
-        metadata: { exportName: config.exportName, file: config.file, line: config.line }
-      })
-    );
-  },
-  source: "static",
-  title: "createAuth session freshAge zero"
-};
-
-export { authSessionFreshageZero as default };

package/dist/packem_shared/authTrustedOriginsWildcard-ylv4PKzC.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const authTrustedOriginsWildcard = {
-  categories: ["SECURITY"],
-  description: "A `createAuth({...})` call's `trustedOrigins` array contains a `\"*\"` entry, disabling better-auth's CSRF/origin validation entirely — any origin is accepted for state-changing auth requests.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "auth_trusted_origins_wildcard",
-  remediation: 'List the specific origins your deployment serves in `trustedOrigins` instead of `"*"` — a wildcard disables origin validation for every caller.',
-  run: (context) => {
-    if (context.authConfigs === void 0) {
-      return [];
-    }
-    return context.authConfigs.filter((config) => config.analyzable && config.trustedOriginsWildcard).map(
-      (config) => emit(authTrustedOriginsWildcard, {
-        cacheKey: `auth_trusted_origins_wildcard:${config.file}:${config.line.toString()}`,
-        detail: `\`createAuth\` in \`${config.exportName}\` (${config.file}:${config.line.toString()}) sets \`trustedOrigins\` to include \`"*"\`, disabling CSRF/origin validation for every request. List the specific origins your deployment serves instead.`,
-        metadata: { exportName: config.exportName, file: config.file, line: config.line }
-      })
-    );
-  },
-  source: "static",
-  title: "createAuth trustedOrigins wildcard"
-};
-
-export { authTrustedOriginsWildcard as default };

package/dist/packem_shared/browserAllowPrivateTargets-CBvQxLAM.mjs

@@ -1,26 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const browserAllowPrivateTargets = {
-  categories: ["SECURITY"],
-  description: "`createBrowser({ allowPrivateTargets: true })` disables the private/internal-IP SSRF guard, letting a navigated URL reach cloud metadata endpoints, internal services, or loopback. Combined with a request-supplied URL this is a server-side request forgery path.",
-  facing: "EXTERNAL",
-  level: "ERROR",
-  name: "browser_allow_private_targets",
-  remediation: "Remove `allowPrivateTargets: true` from `createBrowser({...})` so the private/internal-address guard stays on. If a specific internal host is genuinely required, pin it with an `allowedHosts` allowlist instead of opening all private targets.",
-  run: (context) => {
-    if (context.configCalls === void 0) {
-      return [];
-    }
-    return context.configCalls.filter((call) => call.callee === "createBrowser" && call.trueKeys.includes("allowPrivateTargets")).map(
-      (call) => emit(browserAllowPrivateTargets, {
-        cacheKey: `browser_allow_private_targets:${call.file}:${call.line.toString()}`,
-        detail: `\`createBrowser({ allowPrivateTargets: true })\` in ${call.file}:${call.line.toString()} disables the private/internal-address SSRF guard — a navigated URL can then reach cloud metadata, internal services, or loopback. Remove the override, or pin the specific host with \`allowedHosts\` instead.`,
-        metadata: { callee: call.callee, file: call.file, line: call.line }
-      })
-    );
-  },
-  source: "static",
-  title: "Browser with private-target SSRF guard disabled"
-};
-
-export { browserAllowPrivateTargets as default };

package/dist/packem_shared/browserUserUrlWithoutAllowlist-CvhA6w59.mjs

@@ -1,26 +0,0 @@
-import { m as makeArgumentDerivedSinkLint } from './argument-derived-sink-C1xTTqAt.mjs';
-
-const browserUserUrlWithoutAllowlist = makeArgumentDerivedSinkLint({
-  cacheKey: (access) => `browser_user_url_without_allowlist:${access.file}:${access.line.toString()}`,
-  categories: ["SECURITY"],
-  description: "A `ctx.browser.<method>(url, …)` call navigates to a URL derived from the handler's `args` with no server-side scoping, and no `createBrowser` allowlist contains it. The default guard blocks private targets but not arbitrary public URLs, so any caller can make the headless browser an open-proxy / SSRF tool (fetch arbitrary third-party URLs, DNS-rebind to internal hosts).",
-  detail: (access) => `\`ctx.browser.${access.method}\` in \`${access.exportName}\` (${access.file}:${access.line.toString()}) navigates to a URL derived from \`args\` with no server-side scoping, and no \`createBrowser\` allowlist contains it — the default guard blocks private targets but not arbitrary public URLs, so any caller can turn the headless browser into an open-proxy / SSRF tool. Pin \`allowedHosts\` (and/or \`resolveDns\`) on \`createBrowser({...})\`, and derive the URL from server-trusted state where possible.`,
-  facing: "EXTERNAL",
-  getAccesses: (context) => context.browserUrlAccesses,
-  level: "WARN",
-  metadata: (access) => {
-    return { exportName: access.exportName, file: access.file, line: access.line, method: access.method };
-  },
-  name: "browser_user_url_without_allowlist",
-  remediation: "Pin the browser with an `allowedHosts` allowlist (and/or `resolveDns`) on `createBrowser({...})`, and derive the navigation URL from server-trusted state where possible rather than passing `args` straight to `ctx.browser`.",
-  // A `createBrowser` hardened with an `allowedHosts` allowlist or a pinned
-  // `resolveDns` contains the SSRF surface — suppress every finding when one is
-  // visible. Only an analyzable (non-spread, static object-literal) config call
-  // counts; an opaque config could set the key elsewhere but can't be relied on.
-  suppressWhen: (context) => (context.configCalls ?? []).some(
-    (call) => call.callee === "createBrowser" && call.analyzable && (call.presentKeys.includes("allowedHosts") || call.presentKeys.includes("resolveDns"))
-  ),
-  title: "Browser navigates to arg-derived URL with no allowlist"
-});
-
-export { browserUserUrlWithoutAllowlist as default };

package/dist/packem_shared/circularFk-CNcAVuYa.mjs

@@ -1,127 +0,0 @@
-import { e as emit } from './finding-Dm_zvzS1.mjs';
-
-const MAX_CYCLES = 100;
-const circularFk = {
-  categories: ["SCHEMA"],
-  description: "A chain of foreign-key relations forms a cycle (e.g. A → B → C → A). Circular FK dependencies can cause unexpected behavior during DELETE operations — a CASCADE chain may loop indefinitely, and even a RESTRICT cycle prevents deletion of any row in the loop without temporarily disabling constraints.",
-  facing: "INTERNAL",
-  level: "WARN",
-  name: "circular_fk",
-  remediation: "Remove or break the cycle by dropping at least one FK relation from the loop. Consider replacing the circular dependency with a nullable FK and explicit application logic, or restructure the schema using a junction table.",
-  run: (context) => {
-    const findings = [];
-    const order = [...new Set(context.schema.tables.map((table) => table.name))].sort();
-    const indexOf = new Map(order.map((name, index) => [name, index]));
-    const adjacency = /* @__PURE__ */ new Map();
-    for (const table of context.schema.tables) {
-      for (const relation of table.relations) {
-        if (relation.kind !== "one" || !indexOf.has(relation.table)) {
-          continue;
-        }
-        let targets = adjacency.get(table.name);
-        if (targets === void 0) {
-          targets = /* @__PURE__ */ new Set();
-          adjacency.set(table.name, targets);
-        }
-        targets.add(relation.table);
-      }
-    }
-    const blocked = /* @__PURE__ */ new Set();
-    const blockMap = /* @__PURE__ */ new Map();
-    const stack = [];
-    const reported = /* @__PURE__ */ new Set();
-    let capped = false;
-    const unblock = (vertex) => {
-      blocked.delete(vertex);
-      const dependents = blockMap.get(vertex);
-      if (dependents === void 0) {
-        return;
-      }
-      for (const dependent of dependents) {
-        dependents.delete(dependent);
-        if (blocked.has(dependent)) {
-          unblock(dependent);
-        }
-      }
-    };
-    const emitCurrentCycle = () => {
-      const cycle = [...stack];
-      if (cycle.length < 2) {
-        return;
-      }
-      let minIndex = 0;
-      for (let index = 1; index < cycle.length; index += 1) {
-        if (cycle[index] < cycle[minIndex]) {
-          minIndex = index;
-        }
-      }
-      const canonical = [...cycle.slice(minIndex), ...cycle.slice(0, minIndex)];
-      const key = canonical.join("→");
-      if (reported.has(key)) {
-        return;
-      }
-      reported.add(key);
-      const displayPath = [...canonical, canonical[0]].join(" → ");
-      findings.push(
-        emit(circularFk, {
-          cacheKey: `circular_fk:${key}`,
-          detail: `Circular foreign-key dependency detected: ${displayPath}. This cycle can cause unexpected behavior during DELETE operations.`,
-          metadata: {
-            cycle: canonical,
-            path: displayPath,
-            tables: canonical
-          }
-        })
-      );
-      if (reported.size >= MAX_CYCLES) {
-        capped = true;
-      }
-    };
-    const circuit = (vertex, start, startIndex) => {
-      let foundCycle = false;
-      stack.push(vertex);
-      blocked.add(vertex);
-      for (const neighbor of adjacency.get(vertex) ?? []) {
-        if (capped) {
-          break;
-        }
-        if (indexOf.get(neighbor) < startIndex) {
-          continue;
-        }
-        if (neighbor === start) {
-          emitCurrentCycle();
-          foundCycle = true;
-        } else if (!blocked.has(neighbor) && circuit(neighbor, start, startIndex)) {
-          foundCycle = true;
-        }
-      }
-      if (foundCycle) {
-        unblock(vertex);
-      } else {
-        for (const neighbor of adjacency.get(vertex) ?? []) {
-          if (indexOf.get(neighbor) < startIndex) {
-            continue;
-          }
-          let dependents = blockMap.get(neighbor);
-          if (dependents === void 0) {
-            dependents = /* @__PURE__ */ new Set();
-            blockMap.set(neighbor, dependents);
-          }
-          dependents.add(vertex);
-        }
-      }
-      stack.pop();
-      return foundCycle;
-    };
-    for (let startIndex = 0; startIndex < order.length && !capped; startIndex += 1) {
-      blocked.clear();
-      blockMap.clear();
-      circuit(order[startIndex], order[startIndex], startIndex);
-    }
-    return findings;
-  },
-  source: "static",
-  title: "Circular foreign-key dependency"
-};
-
-export { circularFk as default };