@patchstack/connect 0.5.6 → 0.5.8

package/dist/cli.js

@@ -1,10 +1,131 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
-import path16 from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import path17 from "path";
 import { createRequire as createRequire2 } from "module";
 
+// src/safe-file.ts
+import {
+  chmodSync,
+  closeSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { randomUUID } from "crypto";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function pathError(message) {
+  return Object.assign(new Error(message), { code: "EINVAL" });
+}
+function existingEntry(path18) {
+  try {
+    return lstatSync(path18);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function assertWritableTarget(target) {
+  const entry = existingEntry(target);
+  if (entry?.isSymbolicLink()) throw pathError(`refusing to replace symbolic link: ${target}`);
+  if (entry && !entry.isFile()) throw pathError(`refusing to replace non-file path: ${target}`);
+  return entry;
+}
+function atomicWriteFileSync(target, content, options = {}) {
+  const current = assertWritableTarget(target);
+  const preserveMode = options.preserveMode !== false;
+  const exactMode = options.mode ?? (preserveMode && current ? current.mode & 4095 : options.createMode);
+  const temporary = join(dirname(target), `.${randomUUID()}.patchstack-tmp`);
+  let descriptor = null;
+  try {
+    descriptor = openSync(temporary, "wx", exactMode ?? 438);
+    writeFileSync(descriptor, content, options.encoding);
+    fsyncSync(descriptor);
+    closeSync(descriptor);
+    descriptor = null;
+    if (exactMode !== void 0) chmodSync(temporary, exactMode);
+    try {
+      renameSync(temporary, target);
+    } catch (error) {
+      const code = error.code;
+      if (process.platform !== "win32" || code !== "EEXIST" && code !== "EPERM") throw error;
+      try {
+        unlinkSync(target);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      renameSync(temporary, target);
+    }
+  } catch (error) {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+function projectTarget(cwd, target, allowRoot = false) {
+  const logicalRoot = resolve(cwd);
+  const logicalTarget = isAbsolute(target) ? resolve(target) : resolve(logicalRoot, target);
+  const rel = relative(logicalRoot, logicalTarget);
+  if (!allowRoot && rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    throw pathError(`path is outside the project: ${target}`);
+  }
+  const root = realpathSync(logicalRoot);
+  return { root, path: rel === "" ? root : join(root, rel), parts: rel === "" ? [] : rel.split(sep) };
+}
+function assertProjectParents(root, parts) {
+  let current = root;
+  for (const part of parts.slice(0, -1)) {
+    current = join(current, part);
+    const entry = existingEntry(current);
+    if (entry === null) throw Object.assign(new Error(`project directory does not exist: ${current}`), { code: "ENOENT" });
+    if (entry.isSymbolicLink() || !entry.isDirectory()) {
+      throw pathError(`project path contains a non-directory or symbolic link: ${current}`);
+    }
+  }
+}
+function ensureProjectDirectorySync(cwd, target) {
+  const resolved = projectTarget(cwd, target, true);
+  let current = resolved.root;
+  for (const part of resolved.parts) {
+    current = join(current, part);
+    let entry = existingEntry(current);
+    if (entry === null) {
+      mkdirSync(current);
+      entry = lstatSync(current);
+    }
+    if (entry.isSymbolicLink() || !entry.isDirectory()) {
+      throw pathError(`project path contains a non-directory or symbolic link: ${current}`);
+    }
+  }
+  return resolved.path;
+}
+function writeProjectFileSync(cwd, target, content, options = {}) {
+  const resolved = projectTarget(cwd, target);
+  assertProjectParents(resolved.root, resolved.parts);
+  atomicWriteFileSync(resolved.path, content, options);
+}
+function copyProjectFileSync(cwd, source, target) {
+  const content = readFileSync(source);
+  const sourceMode = statSync(source).mode & 4095;
+  writeProjectFileSync(cwd, target, content, { createMode: sourceMode });
+}
+
 // src/parsers/index.ts
 import { access } from "fs/promises";
 import path5 from "path";
@@ -1217,8 +1338,8 @@ function computeManifestChecksum(packages) {
 var RULES = [
   { platform: "netlify", any: ["NETLIFY", "NETLIFY_BUILD_BASE", "DEPLOY_PRIME_URL"] },
   { platform: "vercel", any: ["VERCEL", "VERCEL_ENV", "VERCEL_URL"] },
-  { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "CLOUDFLARE_ACCOUNT_ID"] },
-  { platform: "aws", any: ["AWS_APP_ID", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
+  { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "WORKERS_CI", "WORKERS_CI_BRANCH", "CLOUDFLARE_ACCOUNT_ID"] },
+  { platform: "aws", any: ["AWS_APP_ID", "AWS_BRANCH", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
   { platform: "render", any: ["RENDER", "RENDER_SERVICE_ID", "RENDER_EXTERNAL_URL"] },
   { platform: "railway", any: ["RAILWAY_ENVIRONMENT", "RAILWAY_ENVIRONMENT_NAME", "RAILWAY_PROJECT_ID"] },
   { platform: "fly", any: ["FLY_APP_NAME", "FLY_REGION", "FLY_ALLOC_ID"] },
@@ -1241,12 +1362,134 @@ function detectHostingPlatform(env = process.env) {
   return { platform: null, evidence: [] };
 }
 
+// src/protect/safe-origin.js
+function isSafeOrigin(value) {
+  try {
+    const u = new URL(value);
+    if (u.protocol === "https:") return true;
+    return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+
+// src/endpoint-policy.ts
+function assertConnectableEndpoint(config, target = config.endpoint) {
+  if (config.endpointTrusted === false) {
+    throw new PatchstackError(
+      "The custom endpoint in .patchstackrc.json must be confirmed with --endpoint or PATCHSTACK_ENDPOINT before it can be used.",
+      "CONFIG_INVALID"
+    );
+  }
+  if (safeRemoteUrl(config.endpoint) === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must use HTTPS, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
+  let endpointOrigin;
+  let targetOrigin;
+  try {
+    endpointOrigin = new URL(config.endpoint).origin;
+    targetOrigin = new URL(target).origin;
+  } catch (cause) {
+    throw new PatchstackError("The configured Patchstack endpoint is not a valid URL.", "CONFIG_INVALID", cause);
+  }
+  if (safeRemoteUrl(target) === null || targetOrigin !== endpointOrigin) {
+    throw new PatchstackError(
+      "A Patchstack request resolved outside the configured endpoint origin.",
+      "CONFIG_INVALID"
+    );
+  }
+}
+function safeRemoteUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048) return null;
+  try {
+    const parsed = new URL(value);
+    if (!isSafeOrigin(parsed.toString()) || parsed.username !== "" || parsed.password !== "") return null;
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+function safeDisplayString(value, maxLength = 512) {
+  if (typeof value !== "string") return null;
+  const clean = value.replace(/\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\))/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+  if (clean.length === 0) return null;
+  return clean.slice(0, maxLength);
+}
+function isCanonicalUuid(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function isCredential(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  const separator = value.lastIndexOf("-");
+  return separator > 0 && separator < value.length - 1 && /^\d+$/.test(value.slice(separator + 1));
+}
+function isHeaderValue(value, maxLength = 8192) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  return true;
+}
+
+// src/bounded-response.ts
+var MAX_CONTROL_RESPONSE_BYTES = 256 * 1024;
+async function readBoundedText(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const stated2 = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated2) && stated2 > maxBytes) {
+    void response.body?.cancel().catch(() => {
+    });
+    throw new Error(`response exceeds ${maxBytes} bytes`);
+  }
+  const stream = response.body;
+  if (stream === null || typeof stream.getReader !== "function") {
+    if (stated2 === 0) return "";
+    throw new Error("response body cannot be read with a size bound");
+  }
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new Error(`response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function readBoundedJson(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const text = await readBoundedText(response, maxBytes);
+  return JSON.parse(text);
+}
+
 // src/pulse-token.ts
 var TOKEN_SKEW_MS = 6e4;
 function buildTokenUrl(manifestEndpoint) {
   const url = new URL(manifestEndpoint);
-  const path17 = url.pathname.replace(/\/$/, "");
-  url.pathname = path17.endsWith("/manifest") ? `${path17.slice(0, -"/manifest".length)}/token` : "/monitor/pulse/token";
+  const path18 = url.pathname.replace(/\/$/, "");
+  url.pathname = path18.endsWith("/manifest") ? `${path18.slice(0, -"/manifest".length)}/token` : "/monitor/pulse/token";
   url.search = "";
   url.hash = "";
   return url.toString();
@@ -1258,22 +1501,48 @@ function parsePulseAuth(credential) {
   if (!/^\d+$/.test(clientId)) return null;
   return { clientId, clientSecret: credential.slice(0, index) };
 }
-var cached = null;
-var inflight = null;
-function clearPulseToken() {
-  cached = null;
+var cached = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+function cacheKey(tokenUrl, credential) {
+  return `${tokenUrl}
+${credential}`;
+}
+function clearPulseToken(config) {
+  if (!config || typeof config.pulseAuth !== "string") {
+    cached.clear();
+    inflight.clear();
+    return;
+  }
+  try {
+    const key = cacheKey(buildTokenUrl(config.endpoint), config.pulseAuth);
+    cached.delete(key);
+    inflight.delete(key);
+  } catch {
+  }
 }
 async function getPulseToken(config, fetchImpl = fetch) {
   if (typeof config.pulseAuth !== "string" || config.pulseAuth.length === 0) return null;
-  if (cached !== null && Date.now() < cached.expiresAt - TOKEN_SKEW_MS) {
-    return cached.token;
+  if (config.endpointTrusted === false) return null;
+  let tokenUrl;
+  try {
+    tokenUrl = buildTokenUrl(config.endpoint);
+  } catch {
+    return null;
+  }
+  if (!isSafeOrigin(tokenUrl)) return null;
+  const key = cacheKey(tokenUrl, config.pulseAuth);
+  const existing = cached.get(key);
+  if (existing !== void 0 && Date.now() < existing.expiresAt - TOKEN_SKEW_MS) {
+    return existing.token;
   }
-  if (inflight !== null) return inflight;
+  const pending = inflight.get(key);
+  if (pending !== void 0) return pending;
   const credentials = parsePulseAuth(config.pulseAuth);
   if (credentials === null) return null;
-  inflight = (async () => {
+  let exchange;
+  exchange = (async () => {
     try {
-      const response = await fetchImpl(buildTokenUrl(config.endpoint), {
+      const response = await fetchImpl(tokenUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -1288,25 +1557,27 @@ async function getPulseToken(config, fetchImpl = fetch) {
         signal: AbortSignal.timeout(config.timeoutMs)
       });
       if (!response.ok) return null;
-      const body = await response.json();
-      if (typeof body.access_token !== "string" || body.access_token.length === 0) return null;
+      const body = await readBoundedJson(response);
+      if (!isHeaderValue(body.access_token)) return null;
       const expiresIn = Number(body.expires_in);
       const ttlMs = Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : 36e5;
-      cached = { token: body.access_token, expiresAt: Date.now() + ttlMs };
+      cached.set(key, { token: body.access_token, expiresAt: Date.now() + ttlMs });
       return body.access_token;
     } catch {
       return null;
     } finally {
-      inflight = null;
+      if (inflight.get(key) === exchange) inflight.delete(key);
     }
   })();
-  return inflight;
+  inflight.set(key, exchange);
+  return exchange;
 }
 async function pulseAuthHeader(config, fetchImpl = fetch) {
   const token = await getPulseToken(config, fetchImpl);
   return token === null ? {} : { Authorization: `Bearer ${token}` };
 }
 async function pulseFetch(config, url, init, fetchImpl = fetch) {
+  assertConnectableEndpoint(config, url);
   const send = async () => {
     const auth = await pulseAuthHeader(config, fetchImpl);
     const response = await fetchImpl(url, {
@@ -1317,7 +1588,7 @@ async function pulseFetch(config, url, init, fetchImpl = fetch) {
   };
   const first = await send();
   if (first.response.status === 401 && first.authenticated) {
-    clearPulseToken();
+    clearPulseToken(config);
     return (await send()).response;
   }
   return first.response;
@@ -1349,12 +1620,13 @@ var DEFAULT_ENDPOINT = "https://api.patchstack.com/monitor/pulse/manifest";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var CLAIM_TOKEN_HEADER = "X-Patchstack-Claim-Token";
 function claimTokenHeader(config) {
-  return typeof config.claimToken === "string" && config.claimToken !== "" ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
+  return config.endpointTrusted !== false && isHeaderValue(config.claimToken) ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
 }
 function claimOutcomeLines(claim3, config) {
   if (typeof config.claimToken !== "string" || config.claimToken === "") return [];
   if (claim3?.state === "claimed" || claim3?.state === "owned-by-you") {
-    const dashboard = typeof claim3.dashboard_url === "string" && claim3.dashboard_url !== "" ? [`Dashboard: ${claim3.dashboard_url}`] : [];
+    const dashboardUrl = safeRemoteUrl(claim3.dashboard_url);
+    const dashboard = dashboardUrl === null ? [] : [`Dashboard: ${dashboardUrl}`];
     return [
       claim3.state === "claimed" ? "Connected to your Patchstack account." : "This site is already connected to your Patchstack account.",
       ...dashboard
@@ -1385,8 +1657,8 @@ function authFailureMessage(status, config) {
 }
 function buildRulesUrl(manifestEndpoint, siteUuid) {
   const url = new URL(manifestEndpoint);
-  const path17 = url.pathname.replace(/\/$/, "");
-  url.pathname = path17.endsWith("/manifest") ? `${path17.slice(0, -"/manifest".length)}/rules/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/rules/${encodeURIComponent(siteUuid)}`;
+  const path18 = url.pathname.replace(/\/$/, "");
+  url.pathname = path18.endsWith("/manifest") ? `${path18.slice(0, -"/manifest".length)}/rules/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/rules/${encodeURIComponent(siteUuid)}`;
   url.search = "";
   url.hash = "";
   return url.toString();
@@ -1401,16 +1673,16 @@ function buildSettingsUrl(endpoint, siteUuid) {
 }
 function buildPackageRemovedUrl(manifestEndpoint, siteUuid) {
   const url = new URL(manifestEndpoint);
-  const path17 = url.pathname.replace(/\/$/, "");
-  url.pathname = path17.endsWith("/manifest") ? `${path17.slice(0, -"/manifest".length)}/package-removed/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/package-removed/${encodeURIComponent(siteUuid)}`;
+  const path18 = url.pathname.replace(/\/$/, "");
+  url.pathname = path18.endsWith("/manifest") ? `${path18.slice(0, -"/manifest".length)}/package-removed/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/package-removed/${encodeURIComponent(siteUuid)}`;
   url.search = "";
   url.hash = "";
   return url.toString();
 }
 function buildInputMapUrl(manifestEndpoint, siteUuid) {
   const url = new URL(manifestEndpoint);
-  const path17 = url.pathname.replace(/\/$/, "");
-  url.pathname = path17.endsWith("/manifest") ? `${path17.slice(0, -"/manifest".length)}/input-map/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/input-map/${encodeURIComponent(siteUuid)}`;
+  const path18 = url.pathname.replace(/\/$/, "");
+  url.pathname = path18.endsWith("/manifest") ? `${path18.slice(0, -"/manifest".length)}/input-map/${encodeURIComponent(siteUuid)}` : `/monitor/pulse/input-map/${encodeURIComponent(siteUuid)}`;
   url.search = "";
   url.hash = "";
   return url.toString();
@@ -1450,7 +1722,7 @@ async function postInputMap(config, map, buildId) {
     if (!response.ok) {
       return { result: "failed", message: `Patchstack returned ${response.status}.` };
     }
-    const body = await response.json();
+    const body = await readBoundedJson(response);
     const revision = Number(body.revision);
     if ((body.result === "stored" || body.result === "unchanged") && Number.isInteger(revision) && revision > 0) {
       return { result: body.result, revision };
@@ -1487,9 +1759,9 @@ async function postPackageRemoved(config) {
     if (!response.ok) {
       return { result: "failed", message: `Patchstack returned ${response.status}.` };
     }
-    const body = await response.json();
+    const body = await readBoundedJson(response);
     if (body.status === "deleted" || body.status === "flagged") {
-      return { result: body.status, message: body.message ?? null };
+      return { result: body.status, message: safeDisplayString(body.message) };
     }
     return { result: "failed", message: "Patchstack returned an unexpected response." };
   } catch {
@@ -1501,6 +1773,7 @@ async function fetchSiteStatus(config) {
   const url = new URL(buildSettingsUrl(config.endpoint, config.siteUuid));
   url.searchParams.set("t", Date.now().toString());
   try {
+    assertConnectableEndpoint(config, url.toString());
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
@@ -1533,6 +1806,42 @@ function validationFields(body) {
   if (typeof errors !== "object" || errors === null || Array.isArray(errors)) return [];
   return Object.keys(errors);
 }
+function manifestResponse(body, provisioning) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const value = body;
+  if (typeof value.stored !== "boolean") return null;
+  const uuid = value.uuid === void 0 ? void 0 : isCanonicalUuid(value.uuid) ? value.uuid : null;
+  if (uuid === null || provisioning && uuid === void 0) return null;
+  if (value.api_key !== void 0 && !isCredential(value.api_key)) return null;
+  if (value.manifest_id !== void 0 && (!Number.isInteger(value.manifest_id) || Number(value.manifest_id) <= 0)) return null;
+  const claimValue = value.claim;
+  let claim3;
+  if (claimValue !== void 0) {
+    if (typeof claimValue !== "object" || claimValue === null || Array.isArray(claimValue)) return null;
+    const raw = claimValue;
+    if (!["claimed", "owned-by-you", "owned-by-other", "rejected"].includes(String(raw.state))) return null;
+    const dashboardUrl = raw.dashboard_url === void 0 || raw.dashboard_url === null ? null : safeRemoteUrl(raw.dashboard_url);
+    if (raw.dashboard_url !== void 0 && raw.dashboard_url !== null && dashboardUrl === null) return null;
+    claim3 = {
+      state: raw.state,
+      ...Number.isInteger(raw.site_id) ? { site_id: Number(raw.site_id) } : {},
+      ...dashboardUrl !== null ? { dashboard_url: dashboardUrl } : {},
+      ...raw.reason === "expired" || raw.reason === "invalid" ? { reason: raw.reason } : {}
+    };
+  }
+  const result = {
+    stored: value.stored,
+    ...uuid !== void 0 ? { uuid } : {},
+    ...typeof value.api_key === "string" ? { api_key: value.api_key } : {},
+    ...Number.isInteger(value.manifest_id) ? { manifest_id: Number(value.manifest_id) } : {},
+    ...safeDisplayString(value.checksum, 256) !== null ? { checksum: safeDisplayString(value.checksum, 256) } : {},
+    ...safeDisplayString(value.reason) !== null ? { reason: safeDisplayString(value.reason) } : {},
+    ...safeDisplayString(value.message) !== null ? { message: safeDisplayString(value.message) } : {},
+    ...safeDisplayString(value.error) !== null ? { error: safeDisplayString(value.error) } : {},
+    ...claim3 !== void 0 ? { claim: claim3 } : {}
+  };
+  return result;
+}
 function environmentRejected(err) {
   return err instanceof PatchstackError && err.code === "VALIDATION_ERROR" && err.fields.includes("environment");
 }
@@ -1551,6 +1860,7 @@ async function postManifestWithEnvironmentFallback(config, payload) {
 async function postManifest(config, payload) {
   const url = buildEndpointUrl(config.endpoint, config.siteUuid);
   const timeoutMs = config.timeoutMs;
+  assertConnectableEndpoint(config, url);
   let response;
   try {
     response = await pulseFetch(config, url, {
@@ -1578,25 +1888,27 @@ async function postManifest(config, payload) {
       cause
     );
   }
-  const text = await response.text();
-  let body = null;
+  let text = "";
+  let parsed = null;
   try {
-    body = text.length > 0 ? JSON.parse(text) : null;
+    text = await readBoundedText(response);
+    parsed = text.length > 0 ? JSON.parse(text) : null;
   } catch {
-    body = null;
+    parsed = null;
   }
+  const body = manifestResponse(parsed, config.siteUuid === null);
   if (response.status === 404) {
     throw new PatchstackError(
-      body?.error ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
+      safeDisplayString(parsed?.error) ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
       "SITE_NOT_FOUND"
     );
   }
   if (response.status === 422) {
     const refused2 = new PatchstackError(
-      body?.message ?? "Patchstack rejected the manifest payload (validation failed).",
+      safeDisplayString(parsed?.message) ?? "Patchstack rejected the manifest payload (validation failed).",
       "VALIDATION_ERROR"
     );
-    refused2.fields = validationFields(body);
+    refused2.fields = validationFields(parsed);
     throw refused2;
   }
   const refused = authFailureMessage(response.status, config);
@@ -1605,12 +1917,12 @@ async function postManifest(config, payload) {
   }
   if (response.status < 200 || response.status >= 300) {
     throw new PatchstackError(
-      `Patchstack returned ${response.status}: ${text.slice(0, 200)}`,
+      `Patchstack returned ${response.status}: ${safeDisplayString(text, 200) ?? "no response details"}`,
       "SERVER_ERROR"
     );
   }
   if (body === null) {
-    throw new PatchstackError("Patchstack returned an empty response.", "SERVER_ERROR");
+    throw new PatchstackError("Patchstack returned an unexpected response.", "SERVER_ERROR");
   }
   return body;
 }
@@ -1623,7 +1935,7 @@ function isTimeoutError(cause) {
 
 // src/demo.ts
 import { readFile as readFile7 } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 var NODE_SERIALIZE_DEMO = {
   name: "node-serialize",
   packageName: "node-serialize",
@@ -1692,7 +2004,7 @@ Add this deliberately vulnerable package first: npm install --save-exact ${scena
 }
 async function readPersistedSiteUuid(cwd) {
   try {
-    const value = JSON.parse(await readFile7(join(cwd, ".patchstackrc.json"), "utf8")).siteUuid;
+    const value = JSON.parse(await readFile7(join2(cwd, ".patchstackrc.json"), "utf8")).siteUuid;
     return typeof value === "string" && value.length > 0 ? value : null;
   } catch {
     return null;
@@ -1777,7 +2089,7 @@ async function waitForDemoRule(manifestEndpoint, siteUuid, scenario, options = {
   const pollIntervalMs = options.pollIntervalMs ?? 1e3;
   const requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
   const fetchFn = options.fetchFn ?? fetch;
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
   const now = options.now ?? Date.now;
   const started = now();
   const rulesUrl = buildRulesUrl(manifestEndpoint, siteUuid);
@@ -1826,13 +2138,25 @@ function renderDemoTestCommands(url, scenario) {
 }
 
 // src/config.ts
-import { readFile as readFile9, writeFile, chmod } from "fs/promises";
+import { readFile as readFile9, chmod, lstat as lstat2, open, rename, unlink } from "fs/promises";
 import path8 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/environment.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import path6 from "path";
 var set = (value) => value !== void 0 && value !== "";
+var PRODUCTION_BRANCHES = /* @__PURE__ */ new Set([
+  "main",
+  "master",
+  "production",
+  "prod",
+  "release",
+  "live"
+]);
+function environmentFromBranch(variable, branch) {
+  return PRODUCTION_BRANCHES.has(branch.toLowerCase()) ? { environment: "production", evidence: `${variable}=${branch} (a production branch by name)` } : { environment: "sandbox", evidence: `${variable}=${branch} (not a production branch by name)` };
+}
 var DISCRIMINATORS = [
   {
     platform: "vercel",
@@ -1861,6 +2185,79 @@ var DISCRIMINATORS = [
       if (!set(env.RAILWAY_ENVIRONMENT_NAME)) return null;
       return env.RAILWAY_ENVIRONMENT_NAME === "production" ? { environment: "production", evidence: "RAILWAY_ENVIRONMENT_NAME=production" } : { environment: "sandbox", evidence: `RAILWAY_ENVIRONMENT_NAME=${env.RAILWAY_ENVIRONMENT_NAME}` };
     }
+  },
+  {
+    // Pages and Workers Builds both name the branch and neither names the tier.
+    platform: "cloudflare",
+    read: (env) => {
+      if (set(env.CF_PAGES) && set(env.CF_PAGES_BRANCH)) {
+        return environmentFromBranch("CF_PAGES_BRANCH", env.CF_PAGES_BRANCH);
+      }
+      if (set(env.WORKERS_CI) && set(env.WORKERS_CI_BRANCH)) {
+        return environmentFromBranch("WORKERS_CI_BRANCH", env.WORKERS_CI_BRANCH);
+      }
+      return null;
+    }
+  },
+  {
+    // Amplify names the branch, and separately whether the build is a pull-request preview.
+    platform: "aws",
+    read: (env) => {
+      if (!set(env.AWS_APP_ID) || !set(env.AWS_BRANCH)) return null;
+      return set(env.AWS_PULL_REQUEST_ID) ? { environment: "sandbox", evidence: "AWS_PULL_REQUEST_ID set (a pull-request preview)" } : environmentFromBranch("AWS_BRANCH", env.AWS_BRANCH);
+    }
+  },
+  {
+    // A Deployment build carries `REPLIT_DEPLOYMENT`; the workspace carries `REPL_ID` alone. Read here,
+    // before the hosted-builder rule, so a workspace build in a Replit project is not its publish step.
+    platform: "replit",
+    read: (env) => {
+      if (set(env.REPLIT_DEPLOYMENT)) {
+        return { environment: "production", evidence: "REPLIT_DEPLOYMENT set (a Replit Deployment build)" };
+      }
+      if (set(env.REPL_ID)) {
+        return { environment: "sandbox", evidence: "REPL_ID set without REPLIT_DEPLOYMENT (the workspace)" };
+      }
+      return null;
+    }
+  },
+  {
+    // GitHub Pages deploys build here. A pull request checks out a merge ref whose name says nothing, so
+    // the event is read first; a tag is a release; otherwise the branch name decides.
+    platform: "github-actions",
+    read: (env) => {
+      if (env.GITHUB_ACTIONS !== "true") return null;
+      if (set(env.GITHUB_EVENT_NAME) && env.GITHUB_EVENT_NAME.startsWith("pull_request")) {
+        return { environment: "sandbox", evidence: `GITHUB_EVENT_NAME=${env.GITHUB_EVENT_NAME} (a pull-request build)` };
+      }
+      if (env.GITHUB_REF_TYPE === "tag") {
+        return { environment: "production", evidence: "GITHUB_REF_TYPE=tag (a tag build)" };
+      }
+      if (!set(env.GITHUB_REF_NAME)) return null;
+      return environmentFromBranch("GITHUB_REF_NAME", env.GITHUB_REF_NAME);
+    }
+  },
+  {
+    // The tier, when a job declares one, is GitLab's own word for it. Without one: a merge request is a
+    // check, a tag is a release, the default branch goes live, and any other branch name decides.
+    platform: "gitlab-ci",
+    read: (env) => {
+      if (env.GITLAB_CI !== "true") return null;
+      if (set(env.CI_ENVIRONMENT_TIER)) {
+        return env.CI_ENVIRONMENT_TIER === "production" ? { environment: "production", evidence: "CI_ENVIRONMENT_TIER=production" } : { environment: "sandbox", evidence: `CI_ENVIRONMENT_TIER=${env.CI_ENVIRONMENT_TIER}` };
+      }
+      if (set(env.CI_MERGE_REQUEST_IID)) {
+        return { environment: "sandbox", evidence: "CI_MERGE_REQUEST_IID set (a merge-request build)" };
+      }
+      if (set(env.CI_COMMIT_TAG)) {
+        return { environment: "production", evidence: "CI_COMMIT_TAG set (a tag build)" };
+      }
+      if (!set(env.CI_COMMIT_BRANCH)) return null;
+      if (set(env.CI_DEFAULT_BRANCH) && env.CI_COMMIT_BRANCH === env.CI_DEFAULT_BRANCH) {
+        return { environment: "production", evidence: `CI_COMMIT_BRANCH=${env.CI_COMMIT_BRANCH} (the default branch)` };
+      }
+      return environmentFromBranch("CI_COMMIT_BRANCH", env.CI_COMMIT_BRANCH);
+    }
   }
 ];
 var HOSTED_BUILDER_PACKAGES = [
@@ -1872,7 +2269,7 @@ var HOSTED_BUILDER_PACKAGES = [
 function detectHostedBuilder(cwd) {
   let declared;
   try {
-    const pkg = JSON.parse(readFileSync(path6.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(path6.join(cwd, "package.json"), "utf8"));
     declared = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   } catch {
     return null;
@@ -2098,7 +2495,15 @@ async function resolveConfig(options) {
   const fromSecretFile = await readSecretFile(options.cwd);
   const fromEnv = readEnv();
   const siteUuid = options.cliSiteUuid ?? fromEnv.siteUuid ?? fromFile.siteUuid ?? null;
-  const endpoint = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
+  const endpointRaw = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
+  const endpointTrusted = endpointRaw === DEFAULT_ENDPOINT || options.cliEndpoint !== void 0 || fromEnv.endpoint !== void 0 || fromFile.endpoint === void 0;
+  const endpoint = safeRemoteUrl(endpointRaw);
+  if (endpoint === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must be valid HTTPS URLs, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
   const timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const environmentRaw = fromEnv.environment ?? fromFile.environment;
   if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
@@ -2110,7 +2515,7 @@ async function resolveConfig(options) {
   const inferred = environmentRaw === void 0 ? inferEnvironment(process.env, detectHostedBuilder(options.cwd)) : null;
   const environment = environmentRaw ?? inferred.environment;
   const environmentEvidence = inferred?.evidence ?? [];
-  if (siteUuid !== null && siteUuid.length > 0 && !isUuid(siteUuid)) {
+  if (siteUuid !== null && siteUuid.length > 0 && !isCanonicalUuid(siteUuid)) {
     throw new PatchstackError(
       `Site UUID "${siteUuid}" does not look like a valid UUID.`,
       "CONFIG_INVALID"
@@ -2133,6 +2538,7 @@ async function resolveConfig(options) {
     siteUrl: identity.url,
     siteName: identity.name,
     endpoint,
+    endpointTrusted,
     timeoutMs,
     environment,
     environmentEvidence,
@@ -2143,13 +2549,13 @@ async function resolveConfig(options) {
 async function writeConfigFile(cwd, config) {
   const target = path8.join(cwd, CONFIG_FILENAME);
   const content = JSON.stringify(config, null, 2) + "\n";
-  await writeFile(target, content, "utf8");
+  await writeAtomicFile(target, content, 420);
   return target;
 }
 var SECRET_CONFIG_FILENAME = SECRET_FILENAME;
 async function writeSecretFile(cwd, secrets) {
   const target = path8.join(cwd, SECRET_FILENAME);
-  await writeFile(target, JSON.stringify(secrets, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+  await writeAtomicFile(target, JSON.stringify(secrets, null, 2) + "\n", 384);
   try {
     await chmod(target, 384);
   } catch {
@@ -2157,6 +2563,39 @@ async function writeSecretFile(cwd, secrets) {
   const ignore = await ensureIgnored(cwd, SECRET_FILENAME);
   return { path: target, ...ignore };
 }
+async function writeAtomicFile(target, content, mode) {
+  const temporary = `${target}.${process.pid}.${randomUUID2()}.tmp`;
+  let handle;
+  try {
+    handle = await open(temporary, "wx", mode);
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    try {
+      await rename(temporary, target);
+    } catch (error) {
+      const code = error.code;
+      if (process.platform !== "win32" || code !== "EEXIST" && code !== "EPERM") throw error;
+      try {
+        await unlink(target);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      await rename(temporary, target);
+    }
+  } catch (error) {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await unlink(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
 async function ensureIgnored(cwd, entry) {
   const target = path8.join(cwd, ".gitignore");
   let existing = "";
@@ -2175,7 +2614,7 @@ async function ensureIgnored(cwd, entry) {
 ${entry}
 `;
   try {
-    await writeFile(target, existing + block, "utf8");
+    await writeAtomicFile(target, existing + block, 420);
   } catch (err) {
     const code = err.code;
     return { ignored: false, reason: `.gitignore could not be written (${code ?? "unknown error"})` };
@@ -2245,8 +2684,15 @@ async function readJsonFile(cwd, filename) {
   const target = path8.join(cwd, filename);
   let raw;
   try {
+    if ((await lstat2(target)).isSymbolicLink()) {
+      throw new PatchstackError(
+        `Could not read ${target}: configuration files must not be symbolic links.`,
+        "CONFIG_INVALID"
+      );
+    }
     raw = await readFile9(target, "utf8");
   } catch (err) {
+    if (err instanceof PatchstackError) throw err;
     if (err.code === "ENOENT") {
       return {};
     }
@@ -2291,15 +2737,12 @@ function readEnv() {
     environment: environmentRaw !== void 0 && environmentRaw.length > 0 ? environmentRaw : void 0
   };
 }
-function isUuid(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
 function isEnvironment(value) {
   return value === "production" || value === "sandbox" || value === "local";
 }
 
 // src/mark-build.ts
-import { existsSync, readFileSync as readFileSync2, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync3, readdirSync, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
 import path9 from "path";
 
 // src/stack.ts
@@ -2401,7 +2844,7 @@ function staleBuildAge(files, startedAt) {
   let newest = null;
   for (const file of files) {
     try {
-      const at = statSync(file).mtimeMs;
+      const at = statSync2(file).mtimeMs;
       if (newest === null || at > newest) newest = at;
     } catch {
       continue;
@@ -2432,20 +2875,20 @@ function buildDirCandidates(options = {}) {
 function resolveBuildDir(cwd, override, options = {}) {
   if (override !== void 0 && override !== "") {
     const abs = path9.resolve(cwd, override);
-    return existsSync(abs) && statSync(abs).isDirectory() ? abs : null;
+    return existsSync(abs) && statSync2(abs).isDirectory() ? abs : null;
   }
   let boundary;
   try {
-    boundary = realpathSync(cwd);
+    boundary = realpathSync2(cwd);
   } catch {
     return null;
   }
   for (const candidate of buildDirCandidates(options)) {
     const abs = path9.resolve(cwd, candidate);
-    if (!existsSync(abs) || !statSync(abs).isDirectory()) continue;
+    if (!existsSync(abs) || !statSync2(abs).isDirectory()) continue;
     let real;
     try {
-      real = realpathSync(abs);
+      real = realpathSync2(abs);
     } catch {
       continue;
     }
@@ -2613,25 +3056,25 @@ function ensureSourceMarker(cwd, shell, framework, checksum = null) {
     return { shell: null, source: "", action: "no-anchor" };
   }
   const file = path9.resolve(cwd, shell);
-  const before = readFileSync2(file, "utf8");
+  const before = readFileSync3(file, "utf8");
   const result = ensureMarkerInJsxShell(before, framework, checksum);
   if (result.source !== before) {
-    writeFileSync(file, result.source);
+    writeProjectFileSync(cwd, file, result.source, { encoding: "utf8" });
   }
   return { ...result, shell };
 }
 
 // src/guide.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync11, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import path12 from "path";
 
 // src/architecture.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
 import path10 from "path";
 
 // src/map/sources.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync2, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
-import { join as join2, relative, isAbsolute } from "path";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { join as join3, relative as relative2, isAbsolute as isAbsolute2 } from "path";
 
 // src/map/ast.ts
 function rootIdentifier(node, ts) {
@@ -2840,7 +3283,7 @@ function hasEntrySignal(text) {
 }
 function detectFramework(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync3(join2(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(join3(cwd, "package.json"), "utf8"));
     const d = { ...pkg.dependencies, ...pkg.devDependencies };
     if (d["@tanstack/react-start"] || d["@tanstack/start"] || d["@tanstack/solid-start"]) return "tanstack-start";
     if (d["next"]) return "next";
@@ -2852,11 +3295,11 @@ function detectFramework(cwd) {
   } catch {
   }
   try {
-    if (statSync2(join2(cwd, "supabase", "functions")).isDirectory()) return "supabase-functions";
+    if (statSync3(join3(cwd, "supabase", "functions")).isDirectory()) return "supabase-functions";
   } catch {
   }
   try {
-    if (statSync2(join2(cwd, "functions")).isDirectory()) return "deno-functions";
+    if (statSync3(join3(cwd, "functions")).isDirectory()) return "deno-functions";
   } catch {
   }
   return "unknown";
@@ -2898,7 +3341,7 @@ function probeForSource(dir, budget) {
   for (const e of entries) {
     if (budget.left-- <= 0) return "unknown";
     if (e.isDirectory()) {
-      if (!SKIP_IS_DEFINITIONAL.has(e.name)) dirs.push(join2(dir, e.name));
+      if (!SKIP_IS_DEFINITIONAL.has(e.name)) dirs.push(join3(dir, e.name));
     } else if (isSourceFile(e.name)) return true;
     else if (e.isSymbolicLink()) return "unknown";
   }
@@ -2911,7 +3354,7 @@ function probeForSource(dir, budget) {
 function collectSources(dir, boundary, opts, out = [], seen = /* @__PURE__ */ new Set(), stats = { discovered: 0, unwalked: 0, skippedWithSource: [], skippedUnknown: 0 }, probeBudget = { left: PROBE_BUDGET }) {
   let key;
   try {
-    key = realpathSync2(dir);
+    key = realpathSync3(dir);
   } catch {
     stats.unwalked++;
     return out;
@@ -2935,19 +3378,19 @@ function collectSources(dir, boundary, opts, out = [], seen = /* @__PURE__ */ ne
       const probeable = !SKIP_IS_DEFINITIONAL.has(e.name);
       if (probeable && !e.isDirectory() && e.isSymbolicLink()) stats.skippedUnknown++;
       else if (probeable && e.isDirectory()) {
-        const held = probeForSource(join2(dir, e.name), probeBudget);
-        if (held === true) stats.skippedWithSource.push(join2(dir, e.name));
+        const held = probeForSource(join3(dir, e.name), probeBudget);
+        if (held === true) stats.skippedWithSource.push(join3(dir, e.name));
         else if (held === "unknown") stats.skippedUnknown++;
       }
       continue;
     }
-    const full = join2(dir, e.name);
+    const full = join3(dir, e.name);
     if (e.isDirectory()) collectSources(full, boundary, opts, out, seen, stats, probeBudget);
     else if (e.isSymbolicLink()) {
       let st, real;
       try {
-        st = statSync2(full);
-        real = realpathSync2(full);
+        st = statSync3(full);
+        real = realpathSync3(full);
       } catch {
         stats.unwalked++;
         continue;
@@ -2970,8 +3413,8 @@ function collectSources(dir, boundary, opts, out = [], seen = /* @__PURE__ */ ne
 }
 function isInside(candidate, boundary) {
   if (candidate === boundary) return true;
-  const rel = relative(boundary, candidate);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+  const rel = relative2(boundary, candidate);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
 }
 var DEPLOYMENT_SHAPES = [
   // Config first: these are declarations by the project itself, and they survive a build output being
@@ -2997,13 +3440,13 @@ var DEPLOYMENT_SHAPES = [
 function detectDeploymentShapes(cwd, opts = {}) {
   let boundary = opts.boundary ?? cwd;
   try {
-    boundary = realpathSync2(boundary);
+    boundary = realpathSync3(boundary);
   } catch {
   }
-  const inProject = (path17) => {
+  const inProject = (path18) => {
     if (opts.followOutside) return true;
     try {
-      return isInside(realpathSync2(path17), boundary);
+      return isInside(realpathSync3(path18), boundary);
     } catch {
       return false;
     }
@@ -3011,9 +3454,9 @@ function detectDeploymentShapes(cwd, opts = {}) {
   const found = [];
   for (const candidate of DEPLOYMENT_SHAPES) {
     for (const file of candidate.files ?? []) {
-      const full = join2(cwd, file);
+      const full = join3(cwd, file);
       try {
-        if (statSync2(full).isFile() && inProject(full)) {
+        if (statSync3(full).isFile() && inProject(full)) {
           found.push({ shape: candidate.shape, source: file, evidence: candidate.evidence });
           break;
         }
@@ -3021,9 +3464,9 @@ function detectDeploymentShapes(cwd, opts = {}) {
       }
     }
     for (const dir of candidate.dirs ?? []) {
-      const full = join2(cwd, dir);
+      const full = join3(cwd, dir);
       try {
-        if (!statSync2(full).isDirectory() || !inProject(full)) continue;
+        if (!statSync3(full).isDirectory() || !inProject(full)) continue;
       } catch {
         continue;
       }
@@ -3040,7 +3483,7 @@ function holdsFunctionEntry(dir) {
     for (const entry of readdirSync2(dir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith("_")) continue;
       try {
-        for (const nested of readdirSync2(join2(dir, entry.name), { withFileTypes: true })) {
+        for (const nested of readdirSync2(join3(dir, entry.name), { withFileTypes: true })) {
           if (nested.isFile() && /^index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(nested.name)) return true;
         }
       } catch {
@@ -3056,7 +3499,7 @@ function holdsSourceFile(dir) {
       if (entry.isFile() && isSourceFile(entry.name)) return true;
       if (entry.isDirectory()) {
         try {
-          for (const nested of readdirSync2(join2(dir, entry.name), { withFileTypes: true })) {
+          for (const nested of readdirSync2(join3(dir, entry.name), { withFileTypes: true })) {
             if (nested.isFile() && isSourceFile(nested.name)) return true;
           }
         } catch {
@@ -3069,8 +3512,8 @@ function holdsSourceFile(dir) {
 }
 
 // src/map/surface.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
 var STATIC_GENERATORS = [
   { dep: "vite", label: "vite" },
   { dep: "react-scripts", label: "create-react-app" },
@@ -3111,7 +3554,7 @@ var SHAPE_SIGNAL = {
 };
 function readManifest(cwd) {
   try {
-    const parsed = JSON.parse(readFileSync4(join3(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync5(join4(cwd, "package.json"), "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : null;
   } catch {
     return null;
@@ -3124,7 +3567,7 @@ function nextExportsStatically(cwd, manifest, ts) {
   for (const file of ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"]) {
     let text;
     try {
-      text = readFileSync4(join3(cwd, file), "utf8");
+      text = readFileSync5(join4(cwd, file), "utf8");
     } catch {
       continue;
     }
@@ -3283,7 +3726,7 @@ var SERVING_CALL = /\b(?:createServer|createSecureServer|Bun\.serve|Deno\.serve|
 var MAX_ENTRY_BYTES = 256 * 1024;
 function readManifest2(cwd) {
   try {
-    const parsed = JSON.parse(readFileSync5(path10.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync6(path10.join(cwd, "package.json"), "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -3317,12 +3760,12 @@ function serverEntries(cwd, manifest) {
     if (!main2.startsWith("..")) candidates.add(main2);
   }
   const found = [];
-  for (const relative7 of candidates) {
-    const file = path10.join(cwd, relative7);
+  for (const relative8 of candidates) {
+    const file = path10.join(cwd, relative8);
     try {
-      if (!existsSync2(file) || !statSync3(file).isFile()) continue;
-      const text = readFileSync5(file, "utf8").slice(0, MAX_ENTRY_BYTES);
-      if (SERVING_CALL.test(text)) found.push(relative7);
+      if (!existsSync2(file) || !statSync4(file).isFile()) continue;
+      const text = readFileSync6(file, "utf8").slice(0, MAX_ENTRY_BYTES);
+      if (SERVING_CALL.test(text)) found.push(relative8);
     } catch {
     }
   }
@@ -3375,14 +3818,14 @@ function classifyArchitecture(cwd) {
 }
 
 // src/protect/install/util.ts
-import { readFileSync as readFileSync6, existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4, dirname } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync3 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-var read = (p) => readFileSync6(p, "utf8");
+var read = (p) => readFileSync7(p, "utf8");
 var log = (msg) => console.log(`patchstack protect: ${msg}`);
 function hasDependency(cwd, name) {
   try {
-    const pkg = JSON.parse(read(join4(cwd, "package.json")));
+    const pkg = JSON.parse(read(join5(cwd, "package.json")));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }[name]);
   } catch {
     return false;
@@ -3394,7 +3837,7 @@ function hasResolvableCredential(cwd, env = process.env) {
   }
   for (const file of [".patchstackrc.local.json", ".patchstackrc.json"]) {
     try {
-      const parsed = JSON.parse(read(join4(cwd, file)));
+      const parsed = JSON.parse(read(join5(cwd, file)));
       if (typeof parsed.apiKey === "string" && parsed.apiKey !== "") return true;
       if (typeof parsed.pulseAuth === "string" && parsed.pulseAuth !== "") return true;
     } catch {
@@ -3408,7 +3851,7 @@ function isSiteUuid(value) {
   return typeof value === "string" && UUID_RE.test(value);
 }
 function bakeSiteUuid(cwd, guardRelPath) {
-  const rc = join4(cwd, ".patchstackrc.json");
+  const rc = join5(cwd, ".patchstackrc.json");
   if (!existsSync3(rc)) {
     log("no .patchstackrc.json \u2014 guard uses PATCHSTACK_SITE_UUID env or the bundled fallback");
     return false;
@@ -3424,32 +3867,32 @@ function bakeSiteUuid(cwd, guardRelPath) {
     log(".patchstackrc.json siteUuid missing or malformed \u2014 guard uses PATCHSTACK_SITE_UUID env or the bundled fallback");
     return false;
   }
-  const guardPath = join4(cwd, guardRelPath);
+  const guardPath = join5(cwd, guardRelPath);
   if (!existsSync3(guardPath)) return false;
   const source = read(guardPath);
   if (!source.includes(SITE_UUID_PLACEHOLDER)) {
     log(`${guardRelPath} site UUID already baked`);
     return false;
   }
-  writeFileSync2(guardPath, source.replace(SITE_UUID_PLACEHOLDER, uuid));
+  writeProjectFileSync(cwd, guardPath, source.replace(SITE_UUID_PLACEHOLDER, uuid), { encoding: "utf8" });
   log(`baked site UUID into ${guardRelPath} \u2014 live rules from the Patchstack API`);
   return true;
 }
-var HERE = dirname(fileURLToPath(import.meta.url));
+var HERE = dirname2(fileURLToPath(import.meta.url));
 function templatesDir() {
-  const builtLayout = join4(HERE, "protect", "templates");
+  const builtLayout = join5(HERE, "protect", "templates");
   const candidates = [
     builtLayout,
-    join4(HERE, "..", "templates"),
+    join5(HERE, "..", "templates"),
     // source: src/protect/install/ → src/protect/templates
-    join4(HERE, "templates")
+    join5(HERE, "templates")
   ];
   return candidates.find((p) => existsSync3(p)) ?? builtLayout;
 }
 
 // src/protect/install/adapters/tanstack-supabase.ts
-import { writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync, copyFileSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
 var CLIENT_TUNNEL = [
   "",
   "    // PATCHSTACK: in the browser, tunnel Supabase traffic through the app's own server guard",
@@ -3519,7 +3962,7 @@ function reconcileBlock(s, region, block, legacyConst, insertBefore) {
   return s.replace(insertBefore, block + "\n\n" + insertBefore);
 }
 function detect(cwd) {
-  const pkgPath = join5(cwd, "package.json");
+  const pkgPath = join6(cwd, "package.json");
   if (!existsSync4(pkgPath)) return false;
   let pkg;
   try {
@@ -3528,22 +3971,22 @@ function detect(cwd) {
     return false;
   }
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-  return Boolean(deps["@tanstack/react-start"]) && existsSync4(join5(cwd, "src/start.ts")) && existsSync4(join5(cwd, "src/integrations/supabase/client.ts"));
+  return Boolean(deps["@tanstack/react-start"]) && existsSync4(join6(cwd, "src/start.ts")) && existsSync4(join6(cwd, "src/integrations/supabase/client.ts"));
 }
 var GUARD_FILE = "src/integrations/patchstack/guard.ts";
 function scaffold(cwd, opts) {
   const templates = templatesDir();
-  const dst = join5(cwd, "src/integrations/patchstack");
-  mkdirSync(dst, { recursive: true });
-  copyFileSync(join5(templates, "guard.ts"), join5(dst, "guard.ts"));
+  const dst = join6(cwd, "src/integrations/patchstack");
+  ensureProjectDirectorySync(cwd, dst);
+  copyProjectFileSync(cwd, join6(templates, "guard.ts"), join6(dst, "guard.ts"));
   const changed = [GUARD_FILE];
-  const rulesDst = join5(dst, "rules.json");
+  const rulesDst = join6(dst, "rules.json");
   if (opts.demo) {
-    copyFileSync(join5(templates, "demo-rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join6(templates, "demo-rules.json"), rulesDst);
     changed.push("src/integrations/patchstack/rules.json");
     log("scaffolded guard.ts + rules.json (demo sample rule set)");
   } else if (!existsSync4(rulesDst)) {
-    copyFileSync(join5(templates, "rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join6(templates, "rules.json"), rulesDst);
     changed.push("src/integrations/patchstack/rules.json");
     log("scaffolded guard.ts + rules.json (starter rules)");
   } else {
@@ -3552,7 +3995,7 @@ function scaffold(cwd, opts) {
   return changed;
 }
 function patchClient(cwd) {
-  const p = join5(cwd, "src/integrations/supabase/client.ts");
+  const p = join6(cwd, "src/integrations/supabase/client.ts");
   const s = read(p);
   if (s.includes("x-ps-target")) {
     log("client.ts already wired");
@@ -3563,12 +4006,12 @@ function patchClient(cwd) {
     log("client.ts anchor not found \u2014 skipping (template changed?)");
     return false;
   }
-  writeFileSync3(p, s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL));
+  writeProjectFileSync(cwd, p, s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL), { encoding: "utf8" });
   log("patched client.ts (tunnel Supabase through the guard)");
   return true;
 }
 function patchStart(cwd) {
-  const p = join5(cwd, "src/start.ts");
+  const p = join6(cwd, "src/start.ts");
   let s = read(p);
   const importAnchor = 'import { createStart, createMiddleware } from "@tanstack/react-start";';
   const exportAnchor = "export const startInstance";
@@ -3600,7 +4043,7 @@ function patchStart(cwd) {
     log("start.ts already wired");
     return false;
   }
-  writeFileSync3(p, s);
+  writeProjectFileSync(cwd, p, s, { encoding: "utf8" });
   log("patched start.ts (guard registered as request + function middleware)");
   return true;
 }
@@ -3615,9 +4058,9 @@ function wire(cwd, opts) {
   return { ok: true, changed: [...new Set(changed)] };
 }
 function verify(cwd) {
-  const guardPath = join5(cwd, GUARD_FILE);
-  const clientPath = join5(cwd, "src/integrations/supabase/client.ts");
-  const startPath = join5(cwd, "src/start.ts");
+  const guardPath = join6(cwd, GUARD_FILE);
+  const clientPath = join6(cwd, "src/integrations/supabase/client.ts");
+  const startPath = join6(cwd, "src/start.ts");
   const guard = existsSync4(guardPath) ? read(guardPath) : "";
   const client = existsSync4(clientPath) ? read(clientPath) : "";
   const start = existsSync4(startPath) ? read(startPath) : "";
@@ -3638,11 +4081,11 @@ var tanstackSupabaseAdapter = {
 };
 
 // src/protect/install/adapters/next.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join7 } from "path";
 function hasNextDep(cwd) {
   try {
-    const pkg = JSON.parse(read(join6(cwd, "package.json")));
+    const pkg = JSON.parse(read(join7(cwd, "package.json")));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.next);
   } catch {
     return false;
@@ -3651,9 +4094,9 @@ function hasNextDep(cwd) {
 function middlewareInfo(cwd) {
   const candidates = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js"];
   for (const rel of candidates) {
-    if (existsSync5(join6(cwd, rel))) return { relDir: rel.includes("/") ? "src" : ".", relFile: rel, exists: true };
+    if (existsSync5(join7(cwd, rel))) return { relDir: rel.includes("/") ? "src" : ".", relFile: rel, exists: true };
   }
-  const useSrc = existsSync5(join6(cwd, "src"));
+  const useSrc = existsSync5(join7(cwd, "src"));
   return { relDir: useSrc ? "src" : ".", relFile: useSrc ? "src/middleware.ts" : "middleware.ts", exists: false };
 }
 function detect2(cwd) {
@@ -3665,15 +4108,15 @@ function rulesFile(relDir) {
 function wire2(cwd, opts) {
   const templates = templatesDir();
   const mw = middlewareInfo(cwd);
-  const dir = join6(cwd, mw.relDir === "." ? "" : mw.relDir);
-  mkdirSync2(dir, { recursive: true });
-  const rulesDst = join6(dir, "patchstack.rules.json");
+  const dir = join7(cwd, mw.relDir === "." ? "" : mw.relDir);
+  ensureProjectDirectorySync(cwd, dir);
+  const rulesDst = join7(dir, "patchstack.rules.json");
   const changed = [];
   if (opts.demo || !existsSync5(rulesDst)) {
-    copyFileSync2(join6(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join7(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
     changed.push(rulesFile(mw.relDir));
   }
-  const mwPath = join6(cwd, mw.relFile);
+  const mwPath = join7(cwd, mw.relFile);
   const existing = mw.exists ? read(mwPath) : "";
   if (mw.exists && existing.includes("patchstack-next")) {
     log(`${mw.relFile} already has the Patchstack middleware \u2014 left as-is`);
@@ -3685,7 +4128,7 @@ function wire2(cwd, opts) {
     );
     return { ok: true, changed };
   }
-  copyFileSync2(join6(templates, "next-middleware.ts"), mwPath);
+  copyProjectFileSync(cwd, join7(templates, "next-middleware.ts"), mwPath);
   if (!opts.demo) bakeSiteUuid(cwd, mw.relFile);
   changed.push(mw.relFile);
   log(`scaffolded ${mw.relFile} (Patchstack middleware)`);
@@ -3693,8 +4136,8 @@ function wire2(cwd, opts) {
 }
 function verify2(cwd) {
   const mw = middlewareInfo(cwd);
-  const present2 = mw.exists && read(join6(cwd, mw.relFile)).includes("patchstack-next");
-  const rulesPresent = existsSync5(join6(cwd, rulesFile(mw.relDir)));
+  const present2 = mw.exists && read(join7(cwd, mw.relFile)).includes("patchstack-next");
+  const rulesPresent = existsSync5(join7(cwd, rulesFile(mw.relDir)));
   return {
     wired: present2 && rulesPresent,
     checks: [
@@ -3712,27 +4155,27 @@ var nextAdapter = {
 };
 
 // src/protect/install/adapters/sveltekit.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/protect/install/seam.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, copyFileSync as copyFileSync3 } from "fs";
-import { join as join7, dirname as dirname2 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
 function rulesRel(seamRel) {
-  const d = dirname2(seamRel);
+  const d = dirname3(seamRel);
   return (d === "." ? "patchstack.rules.json" : `${d}/patchstack.rules.json`).replace(/\\/g, "/");
 }
 function wireSeam(cwd, opts, spec) {
   const templates = templatesDir();
-  const existing = spec.candidates.find((c) => existsSync6(join7(cwd, c)));
+  const existing = spec.candidates.find((c) => existsSync6(join8(cwd, c)));
   const seamRel = existing ?? spec.target;
-  mkdirSync3(dirname2(join7(cwd, seamRel)), { recursive: true });
-  const rulesDst = join7(cwd, rulesRel(seamRel));
+  ensureProjectDirectorySync(cwd, dirname3(join8(cwd, seamRel)));
+  const rulesDst = join8(cwd, rulesRel(seamRel));
   const changed = [];
   if (opts.demo || !existsSync6(rulesDst)) {
-    copyFileSync3(join7(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join8(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
     changed.push(rulesRel(seamRel));
   }
-  const current = existing ? read(join7(cwd, existing)) : "";
+  const current = existing ? read(join8(cwd, existing)) : "";
   if (existing && current.includes(spec.marker)) {
     log(`${existing} already has the Patchstack guard \u2014 left as-is`);
     return { ok: true, changed };
@@ -3741,17 +4184,17 @@ function wireSeam(cwd, opts, spec) {
     log(`existing ${existing} left untouched \u2014 scaffolded ${rulesRel(seamRel)}; ${spec.planHint}`);
     return { ok: true, changed };
   }
-  copyFileSync3(join7(templates, spec.templateName), join7(cwd, seamRel));
+  copyProjectFileSync(cwd, join8(templates, spec.templateName), join8(cwd, seamRel));
   if (!opts.demo) bakeSiteUuid(cwd, seamRel);
   changed.push(seamRel);
   log(`scaffolded ${seamRel}`);
   return { ok: true, changed: [...new Set(changed)] };
 }
 function verifySeam(cwd, spec) {
-  const existing = spec.candidates.find((c) => existsSync6(join7(cwd, c)));
+  const existing = spec.candidates.find((c) => existsSync6(join8(cwd, c)));
   const seamRel = existing ?? spec.target;
-  const present2 = existing ? read(join7(cwd, existing)).includes(spec.marker) : false;
-  const rulesPresent = existsSync6(join7(cwd, rulesRel(seamRel)));
+  const present2 = existing ? read(join8(cwd, existing)).includes(spec.marker) : false;
+  const rulesPresent = existsSync6(join8(cwd, rulesRel(seamRel)));
   return {
     wired: present2 && rulesPresent,
     checks: [
@@ -3772,7 +4215,7 @@ var SPEC = {
 };
 function detect3(cwd) {
   try {
-    const pkg = JSON.parse(read(join8(cwd, "package.json")));
+    const pkg = JSON.parse(read(join9(cwd, "package.json")));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }["@sveltejs/kit"]);
   } catch {
     return false;
@@ -3793,7 +4236,7 @@ var sveltekitAdapter = {
 };
 
 // src/protect/install/adapters/astro.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var SPEC2 = {
   templateName: "astro-middleware.ts",
   candidates: ["src/middleware.ts", "src/middleware.js", "src/middleware/index.ts", "src/middleware/index.js"],
@@ -3804,7 +4247,7 @@ var SPEC2 = {
 };
 function detect4(cwd) {
   try {
-    const pkg = JSON.parse(read(join9(cwd, "package.json")));
+    const pkg = JSON.parse(read(join10(cwd, "package.json")));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.astro);
   } catch {
     return false;
@@ -3851,8 +4294,8 @@ var nuxtAdapter = {
 };
 
 // src/protect/install/find-app.ts
-import { readFileSync as readFileSync7, existsSync as existsSync7, readdirSync as readdirSync3, lstatSync } from "fs";
-import { join as join10, relative as relative2, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync7, readdirSync as readdirSync3, lstatSync as lstatSync2 } from "fs";
+import { join as join11, relative as relative3, dirname as dirname4 } from "path";
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   "patchstack",
@@ -3873,7 +4316,7 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
 ]);
 var MAX_DEPTH = 8;
 function findAppInstance(cwd, re) {
-  const root = existsSync7(join10(cwd, "src")) ? join10(cwd, "src") : cwd;
+  const root = existsSync7(join11(cwd, "src")) ? join11(cwd, "src") : cwd;
   const found = [];
   const walk2 = (dir, depth) => {
     if (depth > MAX_DEPTH) return;
@@ -3885,10 +4328,10 @@ function findAppInstance(cwd, re) {
     }
     for (const name of entries) {
       if (SKIP_DIRS2.has(name) || name.startsWith(".")) continue;
-      const p = join10(dir, name);
+      const p = join11(dir, name);
       let st;
       try {
-        st = lstatSync(p);
+        st = lstatSync2(p);
       } catch {
         continue;
       }
@@ -3897,7 +4340,7 @@ function findAppInstance(cwd, re) {
       else if (/\.(?:ts|js|mjs|cjs)$/.test(name)) {
         let src;
         try {
-          src = readFileSync7(p, "utf8");
+          src = readFileSync8(p, "utf8");
         } catch {
           continue;
         }
@@ -3905,7 +4348,7 @@ function findAppInstance(cwd, re) {
         if (!m) continue;
         const appVar = m[1];
         found.push({
-          relPath: relative2(cwd, p).replace(/\\/g, "/"),
+          relPath: relative3(cwd, p).replace(/\\/g, "/"),
           appVar,
           listens: listensOn(src, appVar)
         });
@@ -3944,7 +4387,7 @@ function declaredEntries(cwd) {
   const paths = /* @__PURE__ */ new Set();
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync7(join10(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync8(join11(cwd, "package.json"), "utf8"));
   } catch {
     return paths;
   }
@@ -3963,24 +4406,24 @@ function declaredEntries(cwd) {
   return paths;
 }
 function importSpecifier(fromRel, toRel, preserveExtension = false) {
-  let spec = relative2(dirname3(fromRel), toRel).replace(/\\/g, "/");
+  let spec = relative3(dirname4(fromRel), toRel).replace(/\\/g, "/");
   if (!preserveExtension) spec = spec.replace(/\.(?:ts|js)$/, "");
   if (!spec.startsWith(".")) spec = `./${spec}`;
   return spec;
 }
 
 // src/protect/install/register.ts
-import { writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
-import { join as join13, resolve as resolve2 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join14, resolve as resolve3 } from "path";
 
 // src/protect/install/generic.ts
-import { readFileSync as readFileSync8, existsSync as existsSync9, mkdirSync as mkdirSync4, copyFileSync as copyFileSync4, readdirSync as readdirSync4, lstatSync as lstatSync2 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync9, readdirSync as readdirSync4, lstatSync as lstatSync3 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 
 // src/protect/install/source-scope.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname4, join as join11, resolve } from "path";
+import { dirname as dirname5, join as join12, resolve as resolve2 } from "path";
 
 // src/protect/install/node-flags.ts
 var flagName = (token) => token.split("=")[0];
@@ -4269,9 +4712,9 @@ function moduleKindOf(filePath, packageIsModule) {
   return packageIsModule ? "esm" : "cjs";
 }
 function resolvesToGuardModule(specifier, query) {
-  const resolved = resolve(dirname4(query.fromFile), specifier);
-  if (withoutModuleExtension(resolved) !== join11(query.guardDir, "guard")) return false;
-  const existing = GUARD_FILENAMES.filter((name) => existsSync8(join11(query.guardDir, name)));
+  const resolved = resolve2(dirname5(query.fromFile), specifier);
+  if (withoutModuleExtension(resolved) !== join12(query.guardDir, "guard")) return false;
+  const existing = GUARD_FILENAMES.filter((name) => existsSync8(join12(query.guardDir, name)));
   if (existing.length === 0) return false;
   const extension = /(\.[A-Za-z0-9]+)$/.exec(specifier)?.[1] ?? "";
   if (!query.strictExtensions) return true;
@@ -4290,16 +4733,16 @@ function withoutModuleExtension(filePath) {
 // src/protect/install/generic.ts
 function packageIsEsm(cwd) {
   try {
-    return JSON.parse(read(join12(cwd, "package.json"))).type === "module";
+    return JSON.parse(read(join13(cwd, "package.json"))).type === "module";
   } catch {
     return false;
   }
 }
 function genericDir(cwd) {
-  return existsSync9(join12(cwd, "src")) ? "src/patchstack" : "patchstack";
+  return existsSync9(join13(cwd, "src")) ? "src/patchstack" : "patchstack";
 }
 function hasTypeScript(cwd) {
-  return existsSync9(join12(cwd, "tsconfig.json")) || candidateEntries(cwd).some((entry) => /\.tsx?$/.test(entry));
+  return existsSync9(join13(cwd, "tsconfig.json")) || candidateEntries(cwd).some((entry) => /\.tsx?$/.test(entry));
 }
 function genericGuardTarget(cwd) {
   if (hasTypeScript(cwd)) {
@@ -4313,7 +4756,7 @@ function genericGuardTarget(cwd) {
 function genericScaffoldFiles(cwd) {
   const dir = genericDir(cwd);
   const candidates = ["guard.ts", "guard.js", "guard.cjs", "rules.json"];
-  return candidates.map((file) => `${dir}/${file}`).filter((relative7) => existsSync9(join12(cwd, relative7)));
+  return candidates.map((file) => `${dir}/${file}`).filter((relative8) => existsSync9(join13(cwd, relative8)));
 }
 function scaffoldGeneric(cwd, opts, guardTemplate, guardFile) {
   const target = genericGuardTarget(cwd);
@@ -4321,15 +4764,15 @@ function scaffoldGeneric(cwd, opts, guardTemplate, guardFile) {
   guardFile ??= target.file;
   const templates = templatesDir();
   const dir = genericDir(cwd);
-  const dst = join12(cwd, dir);
-  mkdirSync4(dst, { recursive: true });
-  copyFileSync4(join12(templates, guardTemplate), join12(dst, guardFile));
+  const dst = join13(cwd, dir);
+  ensureProjectDirectorySync(cwd, dst);
+  copyProjectFileSync(cwd, join13(templates, guardTemplate), join13(dst, guardFile));
   const guardRel = `${dir}/${guardFile}`;
   const changed = [guardRel];
   if (!opts.demo) bakeSiteUuid(cwd, guardRel);
-  const rulesDst = join12(dst, "rules.json");
+  const rulesDst = join13(dst, "rules.json");
   if (opts.demo || !existsSync9(rulesDst)) {
-    copyFileSync4(join12(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join13(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
     changed.push(`${dir}/rules.json`);
   }
   return { changed, dir };
@@ -4350,17 +4793,17 @@ function candidateEntries(cwd) {
     "app.ts",
     "app.js"
   ];
-  const hits = names.filter((n) => existsSync9(join12(cwd, n)));
+  const hits = names.filter((n) => existsSync9(join13(cwd, n)));
   try {
-    const pkg = JSON.parse(read(join12(cwd, "package.json")));
-    if (typeof pkg.main === "string" && existsSync9(join12(cwd, pkg.main))) hits.push(pkg.main);
+    const pkg = JSON.parse(read(join13(cwd, "package.json")));
+    if (typeof pkg.main === "string" && existsSync9(join13(cwd, pkg.main))) hits.push(pkg.main);
   } catch {
   }
   return [...new Set(hits)];
 }
 function usesExpress(cwd) {
   try {
-    const pkg = JSON.parse(read(join12(cwd, "package.json")));
+    const pkg = JSON.parse(read(join13(cwd, "package.json")));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }.express);
   } catch {
     return false;
@@ -4464,9 +4907,9 @@ function escapeForRegExp(value) {
 function genericVerify(cwd) {
   const dir = genericDir(cwd);
   const target = genericGuardTarget(cwd);
-  const present2 = GUARD_FILENAMES.find((name) => existsSync9(join12(cwd, dir, name)));
+  const present2 = GUARD_FILENAMES.find((name) => existsSync9(join13(cwd, dir, name)));
   const scaffolded = present2 !== void 0;
-  const imported = scaffolded && guardIsImported(cwd, join12(cwd, dir, present2));
+  const imported = scaffolded && guardIsImported(cwd, join13(cwd, dir, present2));
   return {
     wired: scaffolded && imported,
     checks: [
@@ -4500,9 +4943,9 @@ var NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
   "__mocks__"
 ]);
 function guardIsImported(cwd, guardPath) {
-  const guardDir = dirname5(guardPath);
+  const guardDir = dirname6(guardPath);
   const packageIsModule = packageIsEsm(cwd);
-  const root = existsSync9(join12(cwd, "src")) ? join12(cwd, "src") : cwd;
+  const root = existsSync9(join13(cwd, "src")) ? join13(cwd, "src") : cwd;
   let found = false;
   const walk2 = (d, depth) => {
     if (found || depth > 8) return;
@@ -4515,10 +4958,10 @@ function guardIsImported(cwd, guardPath) {
     for (const name of entries) {
       if (found) return;
       if (NON_RUNTIME_DIRS.has(name) || name.startsWith(".")) continue;
-      const p = join12(d, name);
+      const p = join13(d, name);
       let st;
       try {
-        st = lstatSync2(p);
+        st = lstatSync3(p);
       } catch {
         continue;
       }
@@ -4526,7 +4969,7 @@ function guardIsImported(cwd, guardPath) {
       if (st.isDirectory()) walk2(p, depth + 1);
       else if (/\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(name) && p !== guardPath) {
         try {
-          if (importsAndUsesGuard(readFileSync8(p, "utf8"), p, guardDir, packageIsModule)) found = true;
+          if (importsAndUsesGuard(readFileSync9(p, "utf8"), p, guardDir, packageIsModule)) found = true;
         } catch {
         }
       }
@@ -4574,7 +5017,7 @@ function guardTarget(cwd, entryRel, spec) {
 }
 function packageType(cwd) {
   try {
-    return JSON.parse(read(join13(cwd, "package.json"))).type;
+    return JSON.parse(read(join14(cwd, "package.json"))).type;
   } catch {
     return void 0;
   }
@@ -4610,8 +5053,8 @@ function bindsGuard(line, maskedLine, importName, call, fileRel, guard) {
 }
 function namesGuardModule(specifier, fileRel, guard) {
   return resolvesToGuardModule(specifier, {
-    fromFile: join13(guard.cwd, fileRel),
-    guardDir: resolve2(join13(guard.cwd, guard.guardDir)),
+    fromFile: join14(guard.cwd, fileRel),
+    guardDir: resolve3(join14(guard.cwd, guard.guardDir)),
     kind: moduleKindOf(fileRel, packageType(guard.cwd) === "module"),
     strictExtensions: true
   });
@@ -4630,7 +5073,7 @@ function wireRegister(cwd, opts, spec) {
   }
   const target = guardTarget(cwd, entry.relPath, spec);
   const { changed, dir } = scaffoldGeneric(cwd, opts, target.template, target.file);
-  const p = join13(cwd, entry.relPath);
+  const p = join14(cwd, entry.relPath);
   const s = read(p);
   const state = wiringState(s, spec, entry.appVar, entry.relPath, { cwd, guardDir: dir });
   if (state.importAtTopLevel && state.callInAppScope) {
@@ -4669,7 +5112,7 @@ function wireRegister(cwd, opts, spec) {
     lines.splice(callIdx + 1, 0, REGION, spec.call(entry.appVar), "// #endregion patchstack");
   }
   const patched = lines.join("\n");
-  writeFileSync5(p, patched);
+  writeProjectFileSync(cwd, p, patched, { encoding: "utf8" });
   if (spec.callAfter) {
     const guardIndex = lines.findIndex((line) => line.includes(spec.call(entry.appVar)));
     const early = routesBefore(patched, entry.appVar, guardIndex);
@@ -4681,7 +5124,7 @@ function wireRegister(cwd, opts, spec) {
   }
   const parsed = parses(p);
   if (parsed === false) {
-    writeFileSync5(p, s);
+    writeProjectFileSync(cwd, p, s, { encoding: "utf8" });
     log(`${entry.relPath} would not parse after patching \u2014 reverted; ${spec.manualHint}`);
     return { ok: true, changed };
   }
@@ -4700,17 +5143,17 @@ function firstStatementLine(lines) {
   return i;
 }
 function serverIsGuarded(cwd, spec, server, guardDir) {
-  const source = read(join13(cwd, server.relPath));
+  const source = read(join14(cwd, server.relPath));
   const state = wiringState(source, spec, server.appVar, server.relPath, { cwd, guardDir });
   if (!state.importAtTopLevel || !state.callInAppScope || !state.ordered) return false;
   return !spec.callAfter || routesBefore(source, server.appVar, state.callIndex).length === 0;
 }
 function verifyRegister(cwd, spec) {
-  const dir = existsSync10(join13(cwd, "src")) ? "src/patchstack" : "patchstack";
+  const dir = existsSync10(join14(cwd, "src")) ? "src/patchstack" : "patchstack";
   const entry = findAppInstance(cwd, spec.appRe);
   const target = entry ? guardTarget(cwd, entry.relPath, spec) : null;
-  const scaffolded = target ? existsSync10(join13(cwd, dir, target.file)) : false;
-  const entrySource = entry ? read(join13(cwd, entry.relPath)) : "";
+  const scaffolded = target ? existsSync10(join14(cwd, dir, target.file)) : false;
+  const entrySource = entry ? read(join14(cwd, entry.relPath)) : "";
   const state = entry ? wiringState(entrySource, spec, entry.appVar, entry.relPath, { cwd, guardDir: dir }) : { importAtTopLevel: false, callInAppScope: false, ordered: false, callIndex: -1, appIndex: -1 };
   const wired = state.importAtTopLevel && state.callInAppScope && state.ordered;
   const early = spec.callAfter && entry ? routesBefore(entrySource, entry.appVar, state.callIndex) : [];
@@ -4801,7 +5244,7 @@ var expressAdapter = {
 
 // src/protect/install/reporting.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/protect/reporting-state.js
 var REPORTING_STATES = Object.freeze([
@@ -4859,7 +5302,7 @@ function explainReportingState(state) {
 
 // src/protect/install/reporting.ts
 function siteIdentity(cwd, env) {
-  const rc = join14(cwd, ".patchstackrc.json");
+  const rc = join15(cwd, ".patchstackrc.json");
   let recorded;
   if (existsSync11(rc)) {
     try {
@@ -5010,7 +5453,7 @@ function runVerify(cwd) {
 }
 
 // src/widget.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import path11 from "path";
 var WIDGET_SCRIPT_URL = "https://cdn.patchstack.com/patchstack-widget.js";
 var WIDGET_MARKER_ATTR = "data-patchstack-connect-widget";
@@ -5064,10 +5507,10 @@ function ensureSourceWidget(cwd, siteUuid, jsxShell = null) {
   if (!existsSync12(file)) {
     return { shell: null, action: "no-shell" };
   }
-  const before = readFileSync9(file, "utf8");
+  const before = readFileSync10(file, "utf8");
   const { html, action } = ensureWidgetInHtml(before, siteUuid);
   if (html !== before) {
-    writeFileSync6(file, html);
+    writeProjectFileSync(cwd, file, html, { encoding: "utf8" });
   }
   return { shell, action };
 }
@@ -5157,7 +5600,7 @@ function installCommand(pm) {
 }
 function readPackageJson(cwd) {
   try {
-    return JSON.parse(readFileSync10(path12.join(cwd, "package.json"), "utf8"));
+    return JSON.parse(readFileSync11(path12.join(cwd, "package.json"), "utf8"));
   } catch {
     return null;
   }
@@ -5165,7 +5608,7 @@ function readPackageJson(cwd) {
 function installedVersion(cwd, declaredRange) {
   try {
     const pkg = JSON.parse(
-      readFileSync10(path12.join(cwd, "node_modules", "@patchstack", "connect", "package.json"), "utf8")
+      readFileSync11(path12.join(cwd, "node_modules", "@patchstack", "connect", "package.json"), "utf8")
     );
     if (typeof pkg.version === "string" && pkg.version.length > 0) {
       return pkg.version;
@@ -5206,10 +5649,10 @@ function findWidgetMarker(cwd, siteUuid) {
       }
       budget -= 1;
       try {
-        if (statSync4(full).size > WIDGET_SCAN_MAX_BYTES) {
+        if (statSync5(full).size > WIDGET_SCAN_MAX_BYTES) {
           continue;
         }
-        const content = readFileSync10(full, "utf8");
+        const content = readFileSync11(full, "utf8");
         if (!content.includes(WIDGET_NEEDLE2)) {
           continue;
         }
@@ -5232,7 +5675,7 @@ function findProductionMarker(cwd, widgetFileHint) {
     return false;
   }
   try {
-    return readFileSync10(path12.join(cwd, widgetFileHint), "utf8").includes(PROD_MARKER_NEEDLE);
+    return readFileSync11(path12.join(cwd, widgetFileHint), "utf8").includes(PROD_MARKER_NEEDLE);
   } catch {
     return false;
   }
@@ -5271,7 +5714,7 @@ async function collectGuideState(cwd) {
   try {
     const config = await resolveConfig({ cwd });
     siteUuid = config.siteUuid;
-    if (siteUuid !== null) {
+    if (siteUuid !== null && config.endpointTrusted !== false) {
       claimUrl = buildClaimUrl(config.endpoint, siteUuid);
     }
     if (config.endpoint !== DEFAULT_ENDPOINT) {
@@ -5535,10 +5978,19 @@ import { tmpdir as tmpdir2 } from "os";
 import path14 from "path";
 
 // src/device-flow.ts
-import { readFileSync as readFileSync11, rmSync, writeFileSync as writeFileSync7 } from "fs";
+import {
+  closeSync as closeSync2,
+  constants,
+  fstatSync,
+  openSync as openSync2,
+  readFileSync as readFileSync12,
+  renameSync as renameSync2,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { tmpdir } from "os";
 import path13 from "path";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
 function baseFrom(manifestEndpoint) {
   const url = new URL(manifestEndpoint);
   const p = url.pathname.replace(/\/$/, "");
@@ -5552,16 +6004,61 @@ function pendingPath(siteUuid, intent) {
   return path13.join(tmpdir(), `patchstack-${intent}-${key}.json`);
 }
 function savePending(siteUuid, intent, pending) {
-  writeFileSync7(pendingPath(siteUuid, intent), JSON.stringify(pending), {
-    encoding: "utf8",
-    mode: 384
-  });
+  const target = pendingPath(siteUuid, intent);
+  const temporary = `${target}.${process.pid}.${randomUUID3()}.tmp`;
+  let descriptor = null;
+  try {
+    descriptor = openSync2(temporary, "wx", 384);
+    writeFileSync2(descriptor, JSON.stringify(pending), "utf8");
+    closeSync2(descriptor);
+    descriptor = null;
+    try {
+      renameSync2(temporary, target);
+    } catch (error) {
+      const code = error.code;
+      if (process.platform !== "win32" || code !== "EEXIST" && code !== "EPERM") throw error;
+      try {
+        rmSync(target);
+      } catch (removeError) {
+        if (removeError.code !== "ENOENT") throw removeError;
+      }
+      renameSync2(temporary, target);
+    }
+  } catch (error) {
+    if (descriptor !== null) {
+      try {
+        closeSync2(descriptor);
+      } catch {
+      }
+    }
+    try {
+      rmSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
 }
 function readPending(siteUuid, intent) {
+  let descriptor = null;
   try {
-    return JSON.parse(readFileSync11(pendingPath(siteUuid, intent), "utf8"));
+    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    descriptor = openSync2(pendingPath(siteUuid, intent), constants.O_RDONLY | noFollow);
+    const stat2 = fstatSync(descriptor);
+    if (!stat2.isFile()) return null;
+    if (typeof process.getuid === "function" && typeof stat2.uid === "number" && stat2.uid !== process.getuid()) {
+      return null;
+    }
+    if (process.platform !== "win32" && (stat2.mode & 63) !== 0) return null;
+    return JSON.parse(readFileSync12(descriptor, "utf8"));
   } catch {
     return null;
+  } finally {
+    if (descriptor !== null) {
+      try {
+        closeSync2(descriptor);
+      } catch {
+      }
+    }
   }
 }
 function clearPending(siteUuid, intent) {
@@ -5579,17 +6076,25 @@ async function requestDeviceCode(config, intent, conflictMessage, deps = {}) {
       message: "No site UUID configured \u2014 run `patchstack-connect scan` first."
     };
   }
-  const base = baseFrom(config.endpoint);
-  const started = await pulseFetch(
-    config,
-    `${base}/device/code`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify({ site_uuid: config.siteUuid, intent })
-    },
-    fetchImpl
-  );
+  let base;
+  let started;
+  try {
+    base = baseFrom(config.endpoint);
+    assertConnectableEndpoint(config, base);
+    started = await pulseFetch(
+      config,
+      `${base}/device/code`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ site_uuid: config.siteUuid, intent }),
+        signal: AbortSignal.timeout(config.timeoutMs)
+      },
+      fetchImpl
+    );
+  } catch {
+    return { status: "failed", message: "Could not start the request." };
+  }
   if (started.status === 409) return { status: "conflict", message: conflictMessage };
   if (started.status === 404) {
     return { status: "not-found", message: "Patchstack does not recognise this site UUID." };
@@ -5597,34 +6102,76 @@ async function requestDeviceCode(config, intent, conflictMessage, deps = {}) {
   if (!started.ok) {
     return { status: "failed", message: `Could not start the request (HTTP ${started.status}).` };
   }
-  const body = await started.json();
+  let body;
+  try {
+    const raw = await readBoundedJson(started);
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error("unexpected response");
+    body = raw;
+  } catch {
+    return { status: "failed", message: "Patchstack returned an unexpected response." };
+  }
+  const deviceCode = safeDisplayString(body.device_code, 2048);
+  const userCode = safeDisplayString(body.user_code, 128);
+  const expiresIn = Number(body.expires_in);
+  const interval = Number(body.interval);
+  if (deviceCode === null || userCode === null || !Number.isInteger(expiresIn) || expiresIn < 1 || expiresIn > 86400 || !Number.isFinite(interval) || interval < 1 || interval > 300) {
+    return { status: "failed", message: "Patchstack returned an unexpected response." };
+  }
   const pending = {
-    deviceCode: body.device_code,
-    userCode: body.user_code,
+    deviceCode,
+    userCode,
     // Points at the API, which redirects to the dashboard SPA — the CLI only knows the API origin,
     // and the approval page lives on the app.
-    verificationUri: `${base}/device?code=${encodeURIComponent(body.user_code)}`,
-    expiresAt: now() + body.expires_in * 1e3,
-    intervalMs: Math.max(1, body.interval) * 1e3
+    verificationUri: `${base}/device?code=${encodeURIComponent(userCode)}`,
+    expiresAt: now() + expiresIn * 1e3,
+    intervalMs: interval * 1e3
   };
   savePending(config.siteUuid, intent, pending);
   return { status: "started", pending };
 }
 async function pollDeviceToken(config, intent, pending, deps = {}) {
   const fetchImpl = deps.fetchImpl ?? fetch;
-  const polled = await fetchImpl(`${baseFrom(config.endpoint)}/device/token`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", Accept: "application/json" },
-    body: JSON.stringify({ device_code: pending.deviceCode })
-  });
+  let polled;
+  try {
+    const url = `${baseFrom(config.endpoint)}/device/token`;
+    assertConnectableEndpoint(config, url);
+    polled = await fetchImpl(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ device_code: pending.deviceCode }),
+      signal: AbortSignal.timeout(config.timeoutMs)
+    });
+  } catch {
+    return { state: "expired" };
+  }
   if (polled.status === 428) return { state: "pending" };
   if (!polled.ok) {
     if (config.siteUuid !== null) clearPending(config.siteUuid, intent);
     return { state: "expired" };
   }
-  const body = await polled.json();
+  let raw;
+  try {
+    raw = await readBoundedJson(polled);
+  } catch {
+    raw = null;
+  }
   if (config.siteUuid !== null) clearPending(config.siteUuid, intent);
-  return { state: "approved", body };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { state: "expired" };
+  const value = raw;
+  const apiKey = value.api_key === void 0 ? void 0 : isCredential(value.api_key) ? value.api_key : null;
+  if (apiKey === null) return { state: "expired" };
+  const dashboardUrl = value.dashboard_url === void 0 ? void 0 : safeRemoteUrl(value.dashboard_url);
+  if (value.dashboard_url !== void 0 && dashboardUrl === null) return { state: "expired" };
+  const account = value.account === void 0 ? void 0 : safeDisplayString(value.account, 256);
+  if (value.account !== void 0 && account === null) return { state: "expired" };
+  return {
+    state: "approved",
+    body: {
+      ...apiKey !== void 0 ? { api_key: apiKey } : {},
+      ...dashboardUrl !== void 0 ? { dashboard_url: dashboardUrl } : {},
+      ...account !== void 0 ? { account } : {}
+    }
+  };
 }
 async function pollUntilApproved(config, intent, pending, deps = {}) {
   const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
@@ -5726,11 +6273,11 @@ async function claim2(config, onPrompt, deps = {}) {
 }
 
 // src/protect/install/runtime/check.ts
-import { relative as relative3 } from "path";
+import { relative as relative4 } from "path";
 
 // src/protect/install/runtime/entry.ts
-import { existsSync as existsSync14, readFileSync as readFileSync12, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
-import { join as join15, resolve as resolve3, sep } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
+import { join as join16, resolve as resolve4, sep as sep2 } from "path";
 var CONVENTIONAL = [
   "server.js",
   "server.mjs",
@@ -5756,31 +6303,31 @@ var CONVENTIONAL = [
 var LOADABLE = /\.(?:js|mjs|cjs)$/;
 function readPackage2(cwd) {
   try {
-    const parsed = JSON.parse(readFileSync12(join15(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync13(join16(cwd, "package.json"), "utf8"));
     return parsed !== null && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
   }
 }
-function isFile(path17) {
+function isFile(path18) {
   try {
-    return statSync5(path17).isFile();
+    return statSync6(path18).isFile();
   } catch {
     return false;
   }
 }
 function loadable(cwd, candidate) {
-  const written = resolve3(cwd, candidate);
+  const written = resolve4(cwd, candidate);
   if (!LOADABLE.test(written) || !isFile(written)) return null;
   let root;
-  let path17;
+  let path18;
   try {
-    root = realpathSync3(cwd);
-    path17 = realpathSync3(written);
+    root = realpathSync4(cwd);
+    path18 = realpathSync4(written);
   } catch {
     return null;
   }
-  if (path17 !== root && !path17.startsWith(root + sep)) return null;
+  if (path18 !== root && !path18.startsWith(root + sep2)) return null;
   return written;
 }
 function passable(token) {
@@ -5826,7 +6373,7 @@ function resolveEntry(cwd) {
   }
   return {
     kind: "unavailable",
-    reason: existsSync14(join15(cwd, "package.json")) ? 'no directly loadable entry was found \u2014 declare one as a "start" script of the form `node <file>`, or run the check against a built output' : "there is no package.json here"
+    reason: existsSync14(join16(cwd, "package.json")) ? 'no directly loadable entry was found \u2014 declare one as a "start" script of the form `node <file>`, or run the check against a built output' : "there is no package.json here"
   };
 }
 
@@ -5860,8 +6407,8 @@ function preloadPath() {
     // beside this file, in the repository
   ];
   for (const candidate of candidates) {
-    const path17 = fileURLToPath2(candidate);
-    if (existsSync15(path17)) return path17;
+    const path18 = fileURLToPath2(candidate);
+    if (existsSync15(path18)) return path18;
   }
   return null;
 }
@@ -5895,7 +6442,7 @@ async function askListener(listener, challenge, answer, budgetMs) {
     timeout: budgetMs
   };
   if (listener.scheme === "https") options.agent = new HttpsAgent({ rejectUnauthorized: false });
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const req = send(options, (res) => {
       const body = [];
       let read2 = 0;
@@ -5909,7 +6456,7 @@ async function askListener(listener, challenge, answer, budgetMs) {
       });
       const finish = () => {
         const text = Buffer.concat(body).toString("utf8").trim();
-        resolve4({
+        resolve5({
           ...listener,
           outcome: text === answer ? "traversed" : "answered-without-sentinel",
           detail: text === answer ? void 0 : `answered with ${res.statusCode ?? "?"} and no sentinel`
@@ -5919,7 +6466,7 @@ async function askListener(listener, challenge, answer, budgetMs) {
       res.on("close", finish);
     });
     req.on("timeout", () => req.destroy(new Error("timed out")));
-    req.on("error", (err) => resolve4({ ...listener, outcome: "unreachable", detail: err.message }));
+    req.on("error", (err) => resolve5({ ...listener, outcome: "unreachable", detail: err.message }));
     req.end();
   });
 }
@@ -6013,12 +6560,12 @@ async function probeRuntimeTraversal(options) {
     let onFrozen = null;
     const freeze = async () => {
       if (!child.connected) return false;
-      return new Promise((resolve4) => {
+      return new Promise((resolve5) => {
         const settle2 = (confirmed2) => {
           clearTimeout(timer);
           onFrozen = null;
           child.removeListener("exit", onGone);
-          resolve4(confirmed2);
+          resolve5(confirmed2);
         };
         const onGone = () => settle2(false);
         const timer = setTimeout(() => settle2(false), Math.min(FREEZE_MS, remaining()));
@@ -6031,13 +6578,13 @@ async function probeRuntimeTraversal(options) {
         }
       });
     };
-    await new Promise((resolve4) => {
+    await new Promise((resolve5) => {
       let settleTimer = null;
       const done = () => {
         discovering = false;
         clearTimeout(runTimer);
         if (settleTimer) clearTimeout(settleTimer);
-        resolve4();
+        resolve5();
       };
       const runTimer = setTimeout(done, remaining());
       const settle2 = () => {
@@ -6177,7 +6724,7 @@ async function runRuntimeCheck(cwd, options = {}) {
     settleMs: options.settleMs,
     platform: options.platform
   });
-  return { ...result, entry: { file: relative3(cwd, entry.file).replace(/\\/g, "/"), from: entry.from } };
+  return { ...result, entry: { file: relative4(cwd, entry.file).replace(/\\/g, "/"), from: entry.from } };
 }
 function runtimeExitCode(report) {
   if (report.outcome === "proven") return 0;
@@ -6208,15 +6755,15 @@ function formatRuntimeCheck(report) {
 }
 
 // src/map-command.ts
-import { writeFileSync as writeFileSync9 } from "fs";
+import path15 from "path";
 
 // src/map/ts-loader.ts
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function loadTypeScript(cwd) {
   try {
-    const req = createRequire(pathToFileURL(join16(cwd, "package.json")));
+    const req = createRequire(pathToFileURL(join17(cwd, "package.json")));
     const resolved = req.resolve("typescript");
     const mod = await import(pathToFileURL(resolved).href);
     return mod.default ?? mod;
@@ -6231,9 +6778,9 @@ async function loadTypeScript(cwd) {
 }
 
 // src/map/extract.ts
-import { readFileSync as readFileSync15, realpathSync as realpathSync5 } from "fs";
+import { readFileSync as readFileSync16, realpathSync as realpathSync6 } from "fs";
 import { createHash as createHash5 } from "crypto";
-import { relative as relative5 } from "path";
+import { relative as relative6 } from "path";
 
 // src/map/bindings.ts
 import { builtinModules } from "module";
@@ -6461,14 +7008,14 @@ function directSinks(node, ts, bindings, ctx) {
     const root = base ? rootIdentifier(base, ts) : void 0;
     if (!root) return {};
     const spec = bindings.resolve(root);
-    const relative7 = spec !== void 0 && (spec.startsWith(".") || spec.startsWith("/"));
+    const relative8 = spec !== void 0 && (spec.startsWith(".") || spec.startsWith("/"));
     const pkg = npmPackageOf(spec);
     if (pkg) return { pkg, root, spec };
-    if (relative7 && ctx && spec) {
+    if (relative8 && ctx && spec) {
       const viaModule = ctx.graph.importedBinding(ctx.file, spec, bindings.exportNameOf(root) ?? root);
       if (viaModule) return { pkg: viaModule.package, root, spec };
     }
-    return { local: bindings.locals.has(root), root, spec, relative: relative7 };
+    return { local: bindings.locals.has(root), root, spec, relative: relative8 };
   };
   const attributionOf = (b, pkg) => b.pkg ? "import" : pkg ? "inferred" : void 0;
   const dbApi = (pkg, attribution) => {
@@ -6645,8 +7192,8 @@ function dedupeSinks(sinks, owner) {
 }
 
 // src/map/module-graph.ts
-import { readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
-import { dirname as dirname7, join as join17, relative as relative4, resolve as resolvePath } from "path";
+import { readFileSync as readFileSync14, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
+import { dirname as dirname8, join as join18, relative as relative5, resolve as resolvePath } from "path";
 var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 function createModuleGraph(ts, opts) {
   const cache = /* @__PURE__ */ new Map();
@@ -6654,7 +7201,7 @@ function createModuleGraph(ts, opts) {
     if (cache.has(file)) return cache.get(file) ?? null;
     let entry = null;
     try {
-      const text = readFileSync13(file, "utf8");
+      const text = readFileSync14(file, "utf8");
       const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, guessScriptKind(ts, file));
       const bindings = buildModuleBindings(sf, ts);
       entry = { fnSinks: collectLocalSinks(sf, ts, bindings), calleesOf: collectCallees(sf, ts), bindings };
@@ -6670,7 +7217,7 @@ function createModuleGraph(ts, opts) {
     if (!opts.followOutside) {
       let real = target;
       try {
-        real = realpathSync4(target);
+        real = realpathSync5(target);
       } catch {
       }
       if (!isInside(real, opts.boundary)) return void 0;
@@ -6688,7 +7235,7 @@ function createModuleGraph(ts, opts) {
       for (const callee of mod.calleesOf.get(exportName) ?? []) {
         for (const s of mod.fnSinks.get(callee) ?? []) collected.push(s);
       }
-      const rel = relative4(opts.cwd, target);
+      const rel = relative5(opts.cwd, target);
       return collected.map((s) => ({ ...s, file: rel }));
     },
     // A different question about the same module: not "what sinks are in there" but "what does this
@@ -6714,7 +7261,7 @@ function createModuleGraph(ts, opts) {
 }
 function resolveRelativeModule(fromFile, spec) {
   if (!spec.startsWith(".")) return void 0;
-  const dir = dirname7(fromFile);
+  const dir = dirname8(fromFile);
   const base = resolvePath(dir, spec);
   const candidates = [];
   const jsLike = /\.(js|jsx|mjs|cjs)$/.exec(base);
@@ -6724,10 +7271,10 @@ function resolveRelativeModule(fromFile, spec) {
   }
   candidates.push(base);
   for (const e of RESOLVE_EXTS) candidates.push(base + e);
-  for (const e of RESOLVE_EXTS) candidates.push(join17(base, "index" + e));
+  for (const e of RESOLVE_EXTS) candidates.push(join18(base, "index" + e));
   for (const c of candidates) {
     try {
-      if (statSync6(c).isFile()) return c;
+      if (statSync7(c).isFile()) return c;
     } catch {
     }
   }
@@ -6753,8 +7300,8 @@ function collectCallees(sf, ts) {
 }
 
 // src/map/coordinates.ts
-function runtimeCoordinate(source, path17) {
-  if (/\[\d*\]/.test(path17)) {
+function runtimeCoordinate(source, path18) {
+  if (/\[\d*\]/.test(path18)) {
     return { runtimeParameter: null, runtimeParameterReason: "array traversal: needs an array_key_value rule, not a dotted parameter" };
   }
   switch (source) {
@@ -6763,15 +7310,15 @@ function runtimeCoordinate(source, path17) {
     case "multipart":
     case "body":
     case "server-fn-data":
-      return { runtimeParameter: `post.${path17}` };
+      return { runtimeParameter: `post.${path18}` };
     case "query":
-      return { runtimeParameter: `get.${path17}` };
+      return { runtimeParameter: `get.${path18}` };
     case "cookie":
-      return { runtimeParameter: `cookie.${path17}` };
+      return { runtimeParameter: `cookie.${path18}` };
     case "file":
-      return { runtimeParameter: `files.${path17}` };
+      return { runtimeParameter: `files.${path18}` };
     case "header":
-      return { runtimeParameter: `server.HTTP_${path17.toUpperCase().replace(/-/g, "_")}` };
+      return { runtimeParameter: `server.HTTP_${path18.toUpperCase().replace(/-/g, "_")}` };
     case "route-param":
       return { runtimeParameter: null, runtimeParameterReason: "route parameters are not exposed by the runtime resolver" };
     default:
@@ -6803,8 +7350,8 @@ function addressSpaceOf(source) {
 function isProvenFlow(confidence) {
   return confidence === "exact-local" || confidence === "transformed-local";
 }
-function inputIdOf(source, path17) {
-  return `${addressSpaceOf(source)}:${path17}`;
+function inputIdOf(source, path18) {
+  return `${addressSpaceOf(source)}:${path18}`;
 }
 function withCoordinates(fields, source) {
   return fields.map((f) => {
@@ -6996,6 +7543,7 @@ function requestMemberAccesses(params, body, ts, opts = {}) {
 }
 
 // src/map/flows.ts
+var MAX_DEPENDENCY_INPUT_FLOWS_PER_ENDPOINT = 100;
 function spaceOfKey(key) {
   if (key === "query") return "get";
   if (key === "params") return "route-param";
@@ -7006,16 +7554,23 @@ function spaceOfKey(key) {
   if (key === "files") return "files";
   return void 0;
 }
-function linkedFlows(body, params, inputs, sinks, ts) {
-  const { flows, limitations } = linkFlows(body, params, inputs, sinks, ts);
-  return limitations.length > 0 ? { flows, limitations } : { flows };
+function linkedFlows(body, params, inputs, sinks, ts, invocations = []) {
+  const { flows, limitations, dependencyInputFlows, dependencyInputFlowsTruncated } = linkFlows(body, params, inputs, sinks, ts, invocations);
+  return {
+    flows,
+    ...limitations.length > 0 ? { limitations } : {},
+    ...dependencyInputFlows.length > 0 ? { dependencyInputFlows } : {},
+    ...dependencyInputFlowsTruncated ? { dependencyInputFlowsTruncated: true } : {}
+  };
 }
-function linkFlows(bodyNode, params, inputs, sinks, ts) {
-  if (!bodyNode || sinks.length === 0 || inputs.length === 0) return { flows: [], limitations: [] };
+function linkFlows(bodyNode, params, inputs, sinks, ts, invocations) {
+  if (!bodyNode || inputs.length === 0 || sinks.length === 0 && invocations.length === 0) {
+    return { flows: [], limitations: [], dependencyInputFlows: [], dependencyInputFlowsTruncated: false };
+  }
   const CONTAINER_KEYS = /* @__PURE__ */ new Set([...REQ_SOURCES, "data", "input", "payload"]);
   const rootPath = /* @__PURE__ */ new Map();
-  const addRoot = (name, path17, space) => {
-    if (!rootPath.has(name)) rootPath.set(name, { path: path17, space });
+  const addRoot = (name, path18, space) => {
+    if (!rootPath.has(name)) rootPath.set(name, { path: path18, space });
   };
   for (const p of params ?? []) {
     if (!p?.name) continue;
@@ -7146,7 +7701,57 @@ function linkFlows(bodyNode, params, inputs, sinks, ts) {
     }
     for (const l of sinkLimits) allLimits.push(l);
   }
-  return { flows, limitations: dedupeLimitations(allLimits) };
+  const dependencyInputFlows = [];
+  let dependencyInputFlowsTruncated = false;
+  const seenDependencyInputs = /* @__PURE__ */ new Set();
+  const modeledCalls = new Set(sinks.filter((s) => s.file === void 0 && s.start !== void 0 && s.end !== void 0).map((s) => `${s.start}:${s.end}`));
+  for (const invocation of invocations) {
+    if (invocation.package.startsWith("node:")) continue;
+    for (const site of invocation.sites) {
+      if (site.start === void 0 || site.end === void 0) continue;
+      const span = `${site.start}:${site.end}`;
+      if (modeledCalls.has(span)) continue;
+      const call = callBySpan.get(span);
+      if (!call) continue;
+      const args = call.arguments ?? [];
+      for (let argumentIndex = 0; argumentIndex < args.length; argumentIndex++) {
+        const argument = args[argumentIndex];
+        if (sinkArgumentLimitations(argument, ts, rootPath).length > 0) continue;
+        const whole = pathFromTainted(argument, ts, rootPath);
+        for (const read2 of taintedReadPaths(argument, ts, rootPath, false)) {
+          if (read2.space === void 0) continue;
+          for (const input of inputs) {
+            if (addressSpaceOf(input.source) !== read2.space) continue;
+            const inputPath = normalizePath(input.name);
+            if (read2.path !== inputPath && !read2.path.startsWith(inputPath + ".")) continue;
+            const key = `${span}:${argumentIndex}:${input.id}:${invocation.package}:${invocation.symbol}`;
+            if (seenDependencyInputs.has(key)) continue;
+            seenDependencyInputs.add(key);
+            if (dependencyInputFlows.length >= MAX_DEPENDENCY_INPUT_FLOWS_PER_ENDPOINT) {
+              dependencyInputFlowsTruncated = true;
+              continue;
+            }
+            dependencyInputFlows.push({
+              input: input.name,
+              inputId: input.id,
+              package: invocation.package,
+              specifier: invocation.specifiers[0],
+              api: invocation.api,
+              symbol: invocation.symbol,
+              kind: invocation.kind,
+              resolution: invocation.resolution,
+              argumentIndex,
+              argumentUse: whole?.path === read2.path && whole.space === read2.space ? "direct" : "within-expression",
+              line: site.line,
+              start: site.start,
+              end: site.end
+            });
+          }
+        }
+      }
+    }
+  }
+  return { flows, limitations: dedupeLimitations(allLimits), dependencyInputFlows, dependencyInputFlowsTruncated };
 }
 function dedupeLimitations(list) {
   const seen = /* @__PURE__ */ new Set();
@@ -7160,8 +7765,8 @@ function dedupeLimitations(list) {
 function join22(base, seg) {
   return base ? `${base}.${seg}` : seg;
 }
-function normalizePath(path17) {
-  return path17.replace(/\[\d*\]/g, "").split(".").filter(Boolean).join(".");
+function normalizePath(path18) {
+  return path18.replace(/\[\d*\]/g, "").split(".").filter(Boolean).join(".");
 }
 function fluentChainCalls(call, ts) {
   let root = call;
@@ -7192,7 +7797,7 @@ function fluentChainCalls(call, ts) {
   collect(root);
   return out;
 }
-function taintedReadPaths(node, ts, rootPath) {
+function taintedReadPaths(node, ts, rootPath, includeDeferredBodies = true) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (r) => {
@@ -7204,6 +7809,7 @@ function taintedReadPaths(node, ts, rootPath) {
   };
   const visit = (n) => {
     if (!n) return;
+    if (!includeDeferredBodies && (ts.isArrowFunction(n) || ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n))) return;
     if (ts.isPropertyAccessExpression(n) || ts.isElementAccessExpression(n)) {
       const read2 = pathFromTainted(n, ts, rootPath);
       if (read2 !== void 0) {
@@ -7286,6 +7892,120 @@ function pathFromTainted(node, ts, rootPath) {
   return { path: normalizePath([base.path, ...segs].filter(Boolean).join(".")), space };
 }
 
+// src/map/invocations.ts
+var MAX_SITES = 3;
+function collectInvocations(sf, ts, bindings, ctx, root = sf) {
+  const found = [];
+  const counts = { total: 0, dependency: 0, local: 0, ambiguous: 0 };
+  const isLocalName = (name, node) => bindings.locals.has(name) || isShadowedByEnclosingBinding(node, name, ts);
+  const lineOf2 = (node) => {
+    try {
+      return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    } catch {
+      return void 0;
+    }
+  };
+  const traceRoot = (root2) => {
+    const specifier = bindings.resolve(root2);
+    if (specifier === void 0) return null;
+    const direct = npmPackageOf(specifier);
+    if (direct !== void 0) {
+      const resolution = bindings.originOf(root2) ?? "direct";
+      return { pkg: direct, specifier, resolution, named: resolution === "direct" };
+    }
+    const exportName = bindings.exportNameOf(root2) ?? root2;
+    const viaModule = ctx.graph.importedBinding(ctx.file, specifier, exportName);
+    if (viaModule !== void 0) {
+      return {
+        pkg: viaModule.package,
+        specifier,
+        resolution: "reexport",
+        named: viaModule.origin === "direct",
+        apiName: viaModule.name
+      };
+    }
+    return null;
+  };
+  const push = (traced, api, receiver, kind, node) => {
+    const span = spanOf(node);
+    found.push({
+      package: traced.pkg,
+      specifiers: [traced.specifier],
+      api,
+      ...receiver !== void 0 ? { receiver } : {},
+      symbol: receiver !== void 0 ? `${receiver}.${api}` : api,
+      kind,
+      // Only ever `import`: a global has no package to correlate against, and an inferred package is not
+      // evidence about the value being called.
+      attribution: "import",
+      resolution: traced.resolution,
+      callCount: 1,
+      sites: [{ file: ctx.owner, line: lineOf2(node), start: span.start, end: span.end }]
+    });
+  };
+  const visit = (node) => {
+    if (root !== sf && node !== root && isUninvokedFunctionDeclaration(node, ts)) return;
+    if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+      const callee = node.expression;
+      counts.total++;
+      if (ts.isIdentifier(callee)) {
+        const traced = traceRoot(callee.text);
+        if (traced?.named) {
+          const api = traced.apiName ?? bindings.exportNameOf(callee.text) ?? callee.text;
+          push(traced, api, void 0, ts.isNewExpression(node) ? "construct" : "call", node);
+          counts.dependency++;
+        } else if (traced) {
+          counts.ambiguous++;
+        } else if (isLocalName(callee.text, node)) {
+          counts.local++;
+        } else {
+          counts.ambiguous++;
+        }
+      } else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
+        const root2 = rootIdentifier(callee.expression, ts);
+        const traced = root2 !== void 0 ? traceRoot(root2) : null;
+        if (traced && root2 !== void 0) {
+          counts.dependency++;
+          const receiver = traced.resolution === "direct" && bindings.isPackageMember(root2) ? bindings.exportNameOf(root2) ?? root2 : void 0;
+          push(traced, callee.name.text, receiver, "member", node);
+        } else if (root2 !== void 0 && ts.isIdentifier(callee.expression) && isLocalName(root2, node)) {
+          counts.local++;
+        } else {
+          counts.ambiguous++;
+        }
+      } else {
+        counts.ambiguous++;
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(root);
+  return { invocations: found, counts };
+}
+function createInvocationInventory() {
+  const byKey = /* @__PURE__ */ new Map();
+  return {
+    add(invocations) {
+      for (const invocation of invocations) {
+        const key = `${invocation.package}|${invocation.symbol}|${invocation.kind}|${invocation.resolution}`;
+        const existing = byKey.get(key);
+        if (existing === void 0) {
+          byKey.set(key, { ...invocation });
+          continue;
+        }
+        existing.callCount += invocation.callCount;
+        for (const specifier of invocation.specifiers) {
+          if (!existing.specifiers.includes(specifier)) existing.specifiers.push(specifier);
+        }
+        if (existing.sites.length < MAX_SITES) existing.sites.push(...invocation.sites.slice(0, MAX_SITES - existing.sites.length));
+      }
+    },
+    list() {
+      return [...byKey.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, invocation]) => ({ ...invocation, specifiers: [...invocation.specifiers].sort() }));
+    }
+  };
+}
+
 // src/map/entries.ts
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 function extractFromFile(sf, ts, localSinks, bindings, ctx) {
@@ -7309,7 +8029,7 @@ function extractFromFile(sf, ts, localSinks, bindings, ctx) {
               ...spanOf(decl),
               inputs,
               sinks,
-              ...linkedFlows(handlerBody, handlerFn?.parameters, inputs, sinks, ts)
+              ...linkedFlows(handlerBody, handlerFn?.parameters, inputs, sinks, ts, handlerInvocations(handlerBody, ts, bindings, ctx))
             };
             if (validatorCall && inputs.length === 0) ep.inputsResolved = false;
             out.push(ep);
@@ -7384,6 +8104,10 @@ function hasUseServerDirective(fn, ts) {
   const first = fn.body?.statements?.[0];
   return Boolean(first && ts.isExpressionStatement(first) && ts.isStringLiteralLike(first.expression) && first.expression.text === "use server");
 }
+function handlerInvocations(body, ts, bindings, ctx) {
+  const sf = body?.getSourceFile?.();
+  return sf ? collectInvocations(sf, ts, bindings, ctx, body).invocations : [];
+}
 function handlerEntry(name, kindLabel, params, body, ts, localSinks, bindings, ctx, extra = {}) {
   const entryKind = kindLabel === "route-registration" || kindLabel === "server-action" || kindLabel === "edge-function" ? kindLabel : "route-handler";
   const payloadStyle = kindLabel === "server-action";
@@ -7402,14 +8126,14 @@ function handlerEntry(name, kindLabel, params, body, ts, localSinks, bindings, c
     end: extra.end,
     inputs,
     sinks,
-    ...linkedFlows(body, params, inputs, sinks, ts)
+    ...linkedFlows(body, params, inputs, sinks, ts, handlerInvocations(body, ts, bindings, ctx))
   };
 }
 
 // src/map/imports.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { join as join18 } from "path";
-var MAX_SITES = 5;
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join19 } from "path";
+var MAX_SITES2 = 5;
 var NPM_NAME = /^(?:@[^/@\s~][^/@\s]*\/)?[^/@\s.~][^/@\s]*$/;
 function isNpmPackageName(pkg) {
   return pkg.startsWith("node:") || NPM_NAME.test(pkg);
@@ -7419,7 +8143,7 @@ function readPathAliases(cwd) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
     let paths;
     try {
-      const raw = readFileSync14(join18(cwd, name), "utf8");
+      const raw = readFileSync15(join19(cwd, name), "utf8");
       const parsed = JSON.parse(stripJsonComments(raw));
       paths = parsed.compilerOptions?.paths;
     } catch {
@@ -7623,7 +8347,7 @@ function createImportInventory(aliases = []) {
         for (const n of edge.names) acc.names.add(n);
         if (!parsed) acc.namesComplete = false;
         acc.siteCount++;
-        if (acc.sites.length < MAX_SITES) acc.sites.push({ file: relFile, line: edge.line });
+        if (acc.sites.length < MAX_SITES2) acc.sites.push({ file: relFile, line: edge.line });
       }
     },
     list() {
@@ -7659,127 +8383,15 @@ function lineAt(starts, pos) {
   return lo + 1;
 }
 
-// src/map/invocations.ts
-var MAX_SITES2 = 3;
-function collectInvocations(sf, ts, bindings, ctx) {
-  const found = [];
-  const counts = { total: 0, dependency: 0, local: 0, ambiguous: 0 };
-  const isLocalName = (name, node) => bindings.locals.has(name) || isShadowedByEnclosingBinding(node, name, ts);
-  const lineOf2 = (node) => {
-    try {
-      return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
-    } catch {
-      return void 0;
-    }
-  };
-  const traceRoot = (root) => {
-    const specifier = bindings.resolve(root);
-    if (specifier === void 0) return null;
-    const direct = npmPackageOf(specifier);
-    if (direct !== void 0) {
-      const resolution = bindings.originOf(root) ?? "direct";
-      return { pkg: direct, specifier, resolution, named: resolution === "direct" };
-    }
-    const exportName = bindings.exportNameOf(root) ?? root;
-    const viaModule = ctx.graph.importedBinding(ctx.file, specifier, exportName);
-    if (viaModule !== void 0) {
-      return {
-        pkg: viaModule.package,
-        specifier,
-        resolution: "reexport",
-        named: viaModule.origin === "direct",
-        apiName: viaModule.name
-      };
-    }
-    return null;
-  };
-  const push = (traced, api, receiver, kind, node) => {
-    const span = spanOf(node);
-    found.push({
-      package: traced.pkg,
-      specifiers: [traced.specifier],
-      api,
-      ...receiver !== void 0 ? { receiver } : {},
-      symbol: receiver !== void 0 ? `${receiver}.${api}` : api,
-      kind,
-      // Only ever `import`: a global has no package to correlate against, and an inferred package is not
-      // evidence about the value being called.
-      attribution: "import",
-      resolution: traced.resolution,
-      callCount: 1,
-      sites: [{ file: ctx.owner, line: lineOf2(node), start: span.start, end: span.end }]
-    });
-  };
-  const visit = (node) => {
-    if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-      const callee = node.expression;
-      counts.total++;
-      if (ts.isIdentifier(callee)) {
-        const traced = traceRoot(callee.text);
-        if (traced?.named) {
-          const api = traced.apiName ?? bindings.exportNameOf(callee.text) ?? callee.text;
-          push(traced, api, void 0, ts.isNewExpression(node) ? "construct" : "call", node);
-          counts.dependency++;
-        } else if (traced) {
-          counts.ambiguous++;
-        } else if (isLocalName(callee.text, node)) {
-          counts.local++;
-        } else {
-          counts.ambiguous++;
-        }
-      } else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
-        const root = rootIdentifier(callee.expression, ts);
-        const traced = root !== void 0 ? traceRoot(root) : null;
-        if (traced && root !== void 0) {
-          counts.dependency++;
-          const receiver = traced.resolution === "direct" && bindings.isPackageMember(root) ? bindings.exportNameOf(root) ?? root : void 0;
-          push(traced, callee.name.text, receiver, "member", node);
-        } else if (root !== void 0 && ts.isIdentifier(callee.expression) && isLocalName(root, node)) {
-          counts.local++;
-        } else {
-          counts.ambiguous++;
-        }
-      } else {
-        counts.ambiguous++;
-      }
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sf);
-  return { invocations: found, counts };
-}
-function createInvocationInventory() {
-  const byKey = /* @__PURE__ */ new Map();
-  return {
-    add(invocations) {
-      for (const invocation of invocations) {
-        const key = `${invocation.package}|${invocation.symbol}|${invocation.kind}|${invocation.resolution}`;
-        const existing = byKey.get(key);
-        if (existing === void 0) {
-          byKey.set(key, { ...invocation });
-          continue;
-        }
-        existing.callCount += invocation.callCount;
-        for (const specifier of invocation.specifiers) {
-          if (!existing.specifiers.includes(specifier)) existing.specifiers.push(specifier);
-        }
-        if (existing.sites.length < MAX_SITES2) existing.sites.push(...invocation.sites.slice(0, MAX_SITES2 - existing.sites.length));
-      }
-    },
-    list() {
-      return [...byKey.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, invocation]) => ({ ...invocation, specifiers: [...invocation.specifiers].sort() }));
-    }
-  };
-}
-
 // src/map/extract.ts
+var MAX_DEPENDENCY_INPUT_FLOWS_PER_MAP = 500;
 async function extractInputMap(cwd, ts, options = {}) {
   const notes = [];
   const endpoints = [];
   const failed = [];
   let boundary = cwd;
   try {
-    boundary = realpathSync5(cwd);
+    boundary = realpathSync6(cwd);
   } catch {
   }
   const graph = createModuleGraph(ts, { cwd, boundary, followOutside: options.followSymlinks });
@@ -7787,6 +8399,7 @@ async function extractInputMap(cwd, ts, options = {}) {
   const files = collectSources(cwd, boundary, { followOutside: options.followSymlinks }, [], /* @__PURE__ */ new Set(), stats);
   const imports = createImportInventory(readPathAliases(cwd));
   const invocations = createInvocationInventory();
+  let dependencyInputFlowCount = 0;
   let parsed = 0;
   let preFiltered = 0;
   let importScanFailures = 0;
@@ -7798,8 +8411,8 @@ async function extractInputMap(cwd, ts, options = {}) {
   const hopTargets = /* @__PURE__ */ new Set();
   for (const file of files) {
     try {
-      const text = readFileSync15(file, "utf8");
-      const relFile = relative5(cwd, file);
+      const text = readFileSync16(file, "utf8");
+      const relFile = relative6(cwd, file);
       sourceBytes += text.length;
       if (!hasEntrySignal(text)) {
         preFiltered++;
@@ -7830,6 +8443,13 @@ async function extractInputMap(cwd, ts, options = {}) {
       calls.ambiguous += called.counts.ambiguous;
       const localSinks = collectLocalSinks(sf, ts, bindings, ctx);
       for (const ep of extractFromFile(sf, ts, localSinks, bindings, ctx)) {
+        const links = ep.dependencyInputFlows ?? [];
+        const remaining = Math.max(0, MAX_DEPENDENCY_INPUT_FLOWS_PER_MAP - dependencyInputFlowCount);
+        if (links.length > remaining) {
+          ep.dependencyInputFlows = links.slice(0, remaining);
+          ep.dependencyInputFlowsTruncated = true;
+        }
+        dependencyInputFlowCount += ep.dependencyInputFlows?.length ?? 0;
         if (ep.route === void 0 && ep.entryKind === "edge-function") {
           const fn = functionNameFromPath(relFile);
           if (fn) ep.route = "/" + fn;
@@ -7845,7 +8465,7 @@ async function extractInputMap(cwd, ts, options = {}) {
       }
     } catch (e) {
       if (typeof process !== "undefined" && process.env?.PS_MAP_DEBUG) console.error("[patchstack] map error", file, e);
-      failed.push(relative5(cwd, file));
+      failed.push(relative6(cwd, file));
     }
   }
   let hopParsed = 0;
@@ -7853,10 +8473,10 @@ async function extractInputMap(cwd, ts, options = {}) {
   for (const target of hopTargets) {
     if (entryFiles.has(target)) continue;
     try {
-      const text = readFileSync15(target, "utf8");
+      const text = readFileSync16(target, "utf8");
       const sf = ts.createSourceFile(target, text, ts.ScriptTarget.Latest, true, guessScriptKind(ts, target));
       const bindings = buildModuleBindings(sf, ts);
-      const called = collectInvocations(sf, ts, bindings, { file: target, owner: relative5(cwd, target), graph });
+      const called = collectInvocations(sf, ts, bindings, { file: target, owner: relative6(cwd, target), graph });
       invocations.add(called.invocations);
       calls.total += called.counts.total;
       calls.dependency += called.counts.dependency;
@@ -7870,6 +8490,9 @@ async function extractInputMap(cwd, ts, options = {}) {
   }
   notes.push("Static analysis is best-effort \u2014 this is the DETECTED surface, not a proof of completeness.");
   notes.push('`inputs` and `sinks` are INVENTORIES (both present in the handler). Only `flows` asserts that an input reaches a sink: require confidence "exact-local" or "transformed-local" before pinning a rule, and identify the input by `inputId` \u2014 a field NAME can occur in more than one request namespace.');
+  if (dependencyInputFlowCount > 0) {
+    notes.push("`dependencyInputFlows` records request inputs observed in arguments of dependency API calls. This is weaker than a modeled sink: it does not establish what the dependency does internally or authorize a blocking rule. Absence is not evidence that no such call exists.");
+  }
   notes.push("Sinks are followed into same-file helpers and ONE hop into an imported relative module (a dependency\u2019s internals are not followed); deeper or dynamic indirection is not traced. Sinks inside declared-but-uncalled local functions are excluded.");
   notes.push('A sink `package` is resolved from the file\u2019s imports (`attribution: "import"`) or inferred from another import in the same file (`"inferred"`); an inferred package is a hint for a reviewer, not evidence about the receiver, and never licenses a rule.');
   if (!options.followSymlinks) notes.push("Symlinks leaving the project directory were not followed (use --follow-symlinks to include them).");
@@ -7878,6 +8501,10 @@ async function extractInputMap(cwd, ts, options = {}) {
     notes.push(`${failed.length} file(s) could not be analyzed and were skipped (fail-open): ${sample}${failed.length > 5 ? ", \u2026" : ""}.`);
   }
   const unresolved = endpoints.filter((e) => e.inputsResolved === false).length;
+  const truncatedDependencyFlows = endpoints.filter((e) => e.dependencyInputFlowsTruncated).length;
+  if (truncatedDependencyFlows > 0) {
+    notes.push(`${truncatedDependencyFlows} endpoint(s) had more dependency-input links than the bounded map carries; those endpoint records are marked dependencyInputFlowsTruncated.`);
+  }
   if (unresolved > 0) {
     notes.push(`${unresolved} endpoint(s) declare an input validator that could not be statically parsed \u2014 their inputs are UNKNOWN, not empty (marked inputsResolved: false).`);
   }
@@ -7888,7 +8515,7 @@ async function extractInputMap(cwd, ts, options = {}) {
   if (endpoints.length === 0) notes.push("No recognized server-side entry points found under the analyzed roots.");
   const importList = imports.list();
   const unmodelled = importList.filter((d) => d.recognizedSinkKinds.length === 0).length;
-  const skippedDirsWithSource = stats.skippedWithSource.map((d) => relative5(cwd, d));
+  const skippedDirsWithSource = stats.skippedWithSource.map((d) => relative6(cwd, d));
   const importCoverageGaps = {
     unreadableFiles: failed.length,
     unscannableFiles: importScanFailures,
@@ -8002,8 +8629,8 @@ function getStringFlag(flags, name) {
 }
 
 // src/build-stamp.ts
-import { chmodSync, lstatSync as lstatSync3, readFileSync as readFileSync16, readdirSync as readdirSync6, realpathSync as realpathSync6, renameSync, unlinkSync, writeFileSync as writeFileSync8 } from "fs";
-import { join as join19, relative as relative6, sep as sep2 } from "path";
+import { lstatSync as lstatSync4, readFileSync as readFileSync17, readdirSync as readdirSync6, realpathSync as realpathSync7 } from "fs";
+import { join as join20, relative as relative7, sep as sep3 } from "path";
 var RULES_FILE_NAMES = /* @__PURE__ */ new Set(["rules.json", "patchstack.rules.json"]);
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage", "tmp", "vendor"]);
 var MAX_DEPTH2 = 6;
@@ -8021,11 +8648,11 @@ function guardImportsRulesFile(dir, rulesName) {
   }
   for (const name of siblings) {
     if (!GUARD_SOURCE.test(name)) continue;
-    const path17 = join19(dir, name);
+    const path18 = join20(dir, name);
     try {
-      const entry = lstatSync3(path17);
+      const entry = lstatSync4(path18);
       if (!entry.isFile() || entry.isSymbolicLink() || entry.size > MAX_GUARD_SOURCE_BYTES) continue;
-      const source = stripComments(readFileSync16(path17, "utf8"));
+      const source = stripComments(readFileSync17(path18, "utf8"));
       if (source.includes("@patchstack/connect/protect") && importsRules.test(source)) return true;
     } catch {
     }
@@ -8042,14 +8669,14 @@ function findRulesFile(cwd) {
   const unreadable = [];
   let root;
   try {
-    root = realpathSync6(cwd);
+    root = realpathSync7(cwd);
   } catch {
     return { kind: "none" };
   }
-  const contained = (path17) => {
+  const contained = (path18) => {
     try {
-      const real = realpathSync6(path17);
-      return real === root || real.startsWith(root + sep2);
+      const real = realpathSync7(path18);
+      return real === root || real.startsWith(root + sep3);
     } catch {
       return false;
     }
@@ -8064,32 +8691,32 @@ function findRulesFile(cwd) {
     }
     for (const name of entries) {
       if (name.startsWith(".")) continue;
-      const path17 = join19(dir, name);
+      const path18 = join20(dir, name);
       let entry;
       try {
-        entry = lstatSync3(path17);
+        entry = lstatSync4(path18);
       } catch {
         continue;
       }
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
-        if (!SKIP_DIRECTORIES.has(name)) walk2(path17, depth + 1);
+        if (!SKIP_DIRECTORIES.has(name)) walk2(path18, depth + 1);
         continue;
       }
       if (!entry.isFile() || !RULES_FILE_NAMES.has(name)) continue;
-      if (!contained(path17)) continue;
+      if (!contained(path18)) continue;
       if (!guardImportsRulesFile(dir, name)) continue;
       try {
-        if (isRuleBundle(JSON.parse(readFileSync16(path17, "utf8")))) found.push(path17);
+        if (isRuleBundle(JSON.parse(readFileSync17(path18, "utf8")))) found.push(path18);
       } catch {
-        unreadable.push(path17);
+        unreadable.push(path18);
       }
     }
   };
   walk2(cwd, 0);
-  if (found.length > 1) return { kind: "ambiguous", paths: found.map((p) => relative6(cwd, p)) };
+  if (found.length > 1) return { kind: "ambiguous", paths: found.map((p) => relative7(cwd, p)) };
   if (found.length === 1) return { kind: "one", path: found[0] };
-  if (unreadable.length > 0) return { kind: "unreadable", paths: unreadable.map((p) => relative6(cwd, p)) };
+  if (unreadable.length > 0) return { kind: "unreadable", paths: unreadable.map((p) => relative7(cwd, p)) };
   return { kind: "none" };
 }
 function detectIndent(text) {
@@ -8110,10 +8737,10 @@ function applyBuildStamp(cwd, id) {
       reason: `more than one candidate guard rules file (${location.paths.join(", ")}) \u2014 none was stamped`
     };
   }
-  const file = relative6(cwd, location.path);
+  const file = relative7(cwd, location.path);
   let text;
   try {
-    text = readFileSync16(location.path, "utf8");
+    text = readFileSync17(location.path, "utf8");
   } catch (err) {
     return { kind: "skipped", reason: `${file} could not be read (${err.message})` };
   }
@@ -8133,17 +8760,9 @@ function applyBuildStamp(cwd, id) {
   if (Object.keys(namespace).length === 0) delete bundle[BUILD_STAMP_KEY];
   else bundle[BUILD_STAMP_KEY] = namespace;
   const serialised = JSON.stringify(bundle, null, detectIndent(text)) + (text.endsWith("\n") ? "\n" : "");
-  const temporary = `${location.path}.patchstack-${process.pid}.tmp`;
   try {
-    const mode = lstatSync3(location.path).mode & 4095;
-    writeFileSync8(temporary, serialised, { encoding: "utf8", mode });
-    chmodSync(temporary, mode);
-    renameSync(temporary, location.path);
+    writeProjectFileSync(cwd, location.path, serialised, { encoding: "utf8" });
   } catch (err) {
-    try {
-      unlinkSync(temporary);
-    } catch {
-    }
     return { kind: "skipped", reason: `${file} could not be written (${err.message})` };
   }
   return id === null ? { kind: "cleared", file } : { kind: "stamped", file, id };
@@ -8282,7 +8901,7 @@ async function runMap(flags) {
   const json = JSON.stringify(map, null, 2);
   const out = getStringFlag(flags, "out");
   if (out) {
-    writeFileSync9(out, json);
+    atomicWriteFileSync(path15.resolve(out), json, { encoding: "utf8" });
     console.error(`patchstack: wrote ${out}`);
   } else if (flags.get("upload") !== true) {
     console.log(json);
@@ -8331,8 +8950,8 @@ async function runMap(flags) {
 }
 
 // src/setup.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
-import path15 from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import path16 from "path";
 var SCAN_COMMAND = "patchstack-connect scan";
 var MARK_BUILD_COMMAND = "patchstack-connect mark-build";
 function setupProtection(cwd) {
@@ -8357,8 +8976,8 @@ function prependHook(existing, command) {
   return [command, ...remaining].join(" && ");
 }
 function wireBuildScripts(cwd, packageManager) {
-  const target = path15.join(cwd, "package.json");
-  const raw = readFileSync17(target, "utf8");
+  const target = path16.join(cwd, "package.json");
+  const raw = readFileSync18(target, "utf8");
   const pkg = JSON.parse(raw);
   const scripts = pkg.scripts ?? {};
   const build = scripts.build;
@@ -8404,7 +9023,7 @@ function wireBuildScripts(cwd, packageManager) {
   const indentMatch = raw.match(/^[\t ]+(?=")/m)?.[0];
   const indent = indentMatch?.includes("	") ? "	" : indentMatch?.length ?? 2;
   const trailingNewline = raw.endsWith("\n") ? "\n" : "";
-  writeFileSync10(target, `${JSON.stringify(pkg, null, indent)}${trailingNewline}`, "utf8");
+  writeProjectFileSync(cwd, target, `${JSON.stringify(pkg, null, indent)}${trailingNewline}`, { encoding: "utf8" });
   if (build === void 0 || build.trim().length === 0) {
     return {
       changed: true,
@@ -8578,7 +9197,7 @@ Environment:
   PATCHSTACK_API_BASE     API origin for /oauth/token and /api/logs/log (default: https://api.patchstack.com)
   PATCHSTACK_ENDPOINT     API endpoint (default: https://api.patchstack.com/monitor/pulse/manifest)
   PATCHSTACK_TIMEOUT_MS   Request timeout in ms (default: 30000; a scan that needs longer saves what worked to .patchstackrc.json)
-  PATCHSTACK_ENVIRONMENT  Manifest label: production, sandbox or local. Unset, a deployment or CI build reports production and a developer machine reports local.
+  PATCHSTACK_ENVIRONMENT  Manifest label: production, sandbox or local. Unset, the build platform's own tier or branch name decides; a developer machine reports local.
   PATCHSTACK_MODE         (protect) Runtime guard mode: block (default) | dry-run
   PATCHSTACK_ROUTE_WAF    (protect) Set to 1 to also screen every request at the route level (opt-in)
 
@@ -8887,7 +9506,7 @@ async function runScan(args, options = {}) {
   }
   if (config.environment === "local") {
     console.log(
-      "Reporting from this machine as the local environment: the dashboard will show the app as configured, not deployed. Builds on your hosting platform report as production."
+      "Reporting from this machine as the local environment: the dashboard will show the app as configured, not deployed. A build on a platform this recognises reports production or sandbox on its own; on a platform it does not know, set PATCHSTACK_ENVIRONMENT=production for the build that goes live."
     );
   } else {
     const because = (config.environmentEvidence ?? []).length > 0 ? ` (${config.environmentEvidence.join("; ")})` : "";
@@ -9241,7 +9860,7 @@ async function runGuide(args) {
   console.log("\u2014\u2014\u2014\u2014 Full reference guide (ships as AGENT-INSTALL.md) \u2014\u2014\u2014\u2014");
   console.log("");
   const guidePath = new URL("../AGENT-INSTALL.md", import.meta.url);
-  console.log(readFileSync18(guidePath, "utf8"));
+  console.log(readFileSync19(guidePath, "utf8"));
   return 0;
 }
 async function runSetup(args) {
@@ -9416,7 +10035,7 @@ function describeStack(stack) {
 }
 function readBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync18(path16.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync19(path17.join(cwd, "package.json"), "utf8"));
     return pkg.scripts?.build;
   } catch {
     return void 0;
@@ -9496,7 +10115,7 @@ async function runMarkBuild(args) {
   let marked = 0;
   let widgetTouched = 0;
   for (const file of files) {
-    const before = readFileSync18(file, "utf8");
+    const before = readFileSync19(file, "utf8");
     let after = injectMarker(before, snippet);
     if (widgetUuid !== null) {
       const ensured = ensureWidgetInHtml(after, widgetUuid);
@@ -9506,7 +10125,7 @@ async function runMarkBuild(args) {
       after = ensured.html;
     }
     if (after !== before) {
-      writeFileSync11(file, after);
+      writeProjectFileSync(cwd, file, after, { encoding: "utf8" });
       marked += 1;
     }
   }