@patchstack/connect 0.3.18 → 0.3.20

package/dist/refresh-manifest-XBOGN446.js

@@ -0,0 +1,1090 @@
+// src/config.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/types.ts
+var PatchstackError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "PatchstackError";
+  }
+  code;
+  cause;
+};
+
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://api.patchstack.com/monitor/pulse/manifest";
+var DEFAULT_TIMEOUT_MS = 3e4;
+function buildEndpointUrl(base, siteUuid) {
+  const trimmed = base.replace(/\/$/, "");
+  return siteUuid !== void 0 && siteUuid !== null && siteUuid.length > 0 ? `${trimmed}/${encodeURIComponent(siteUuid)}` : trimmed;
+}
+async function postManifest(config, payload) {
+  const url = buildEndpointUrl(config.endpoint, config.siteUuid);
+  const timeoutMs = config.timeoutMs;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": "@patchstack/connect"
+      },
+      body: JSON.stringify({ ...payload, environment: config.environment }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    if (isTimeoutError(cause)) {
+      throw new PatchstackError(
+        `Patchstack request to ${url} timed out after ${timeoutMs}ms. Override with PATCHSTACK_TIMEOUT_MS.`,
+        "NETWORK_TIMEOUT",
+        cause
+      );
+    }
+    throw new PatchstackError(
+      `Could not reach Patchstack at ${url}. Check your network connection.`,
+      "NETWORK_ERROR",
+      cause
+    );
+  }
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text.length > 0 ? JSON.parse(text) : null;
+  } catch {
+    body = 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.",
+      "SITE_NOT_FOUND"
+    );
+  }
+  if (response.status === 422) {
+    throw new PatchstackError(
+      body?.message ?? "Patchstack rejected the manifest payload (validation failed).",
+      "VALIDATION_ERROR"
+    );
+  }
+  if (response.status < 200 || response.status >= 300) {
+    throw new PatchstackError(
+      `Patchstack returned ${response.status}: ${text.slice(0, 200)}`,
+      "SERVER_ERROR"
+    );
+  }
+  if (body === null) {
+    throw new PatchstackError("Patchstack returned an empty response.", "SERVER_ERROR");
+  }
+  return body;
+}
+function isTimeoutError(cause) {
+  if (cause instanceof Error) {
+    return cause.name === "TimeoutError" || cause.name === "AbortError";
+  }
+  return false;
+}
+
+// src/config.ts
+var CONFIG_FILENAME = ".patchstackrc.json";
+var DEFAULT_ENVIRONMENT = "production";
+async function resolveConfig(options) {
+  const fromFile = await readConfigFile(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 timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const environmentRaw = fromEnv.environment ?? fromFile.environment;
+  if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
+    throw new PatchstackError(
+      `Environment must be "production" or "sandbox"; got "${environmentRaw}".`,
+      "CONFIG_INVALID"
+    );
+  }
+  const environment = environmentRaw ?? DEFAULT_ENVIRONMENT;
+  if (siteUuid !== null && siteUuid.length > 0 && !isUuid(siteUuid)) {
+    throw new PatchstackError(
+      `Site UUID "${siteUuid}" does not look like a valid UUID.`,
+      "CONFIG_INVALID"
+    );
+  }
+  if (options.requireSiteUuid && (siteUuid === null || siteUuid.length === 0)) {
+    throw new PatchstackError(
+      "No site UUID configured. Run `patchstack-connect scan` to provision one, or set PATCHSTACK_SITE_UUID.",
+      "CONFIG_MISSING"
+    );
+  }
+  return {
+    siteUuid: siteUuid === null || siteUuid.length === 0 ? null : siteUuid,
+    endpoint,
+    timeoutMs,
+    environment,
+    widget: fromFile.widget !== false
+  };
+}
+async function readConfigFile(cwd) {
+  const target = path.join(cwd, CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(target, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw new PatchstackError(
+      `Could not read ${target}: ${err.message}`,
+      "CONFIG_INVALID",
+      err
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new PatchstackError(
+      `Config file ${target} contains invalid JSON.`,
+      "CONFIG_INVALID",
+      err
+    );
+  }
+}
+function readEnv() {
+  const timeoutRaw = process.env.PATCHSTACK_TIMEOUT_MS;
+  let timeoutMs;
+  if (timeoutRaw !== void 0 && timeoutRaw.length > 0) {
+    const parsed = Number(timeoutRaw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new PatchstackError(
+        `PATCHSTACK_TIMEOUT_MS must be a positive number; got "${timeoutRaw}".`,
+        "CONFIG_INVALID"
+      );
+    }
+    timeoutMs = parsed;
+  }
+  const environmentRaw = process.env.PATCHSTACK_ENVIRONMENT;
+  return {
+    siteUuid: process.env.PATCHSTACK_SITE_UUID ?? void 0,
+    endpoint: process.env.PATCHSTACK_ENDPOINT ?? void 0,
+    timeoutMs,
+    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";
+}
+
+// src/parsers/index.ts
+import { access } from "fs/promises";
+import path6 from "path";
+
+// src/parsers/consistency.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+async function readDeclaredDependencyNames(cwd) {
+  let raw;
+  try {
+    raw = await readFile2(path2.join(cwd, "package.json"), "utf8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const group of ["dependencies", "devDependencies"]) {
+    const deps = parsed[group];
+    if (typeof deps !== "object" || deps === null) {
+      continue;
+    }
+    for (const [name, spec] of Object.entries(deps)) {
+      if (typeof spec === "string" && /^(file|link|workspace|portal):/.test(spec)) {
+        continue;
+      }
+      names.add(name);
+    }
+  }
+  return [...names];
+}
+function missingDependencies(declared, packages) {
+  const present = new Set(packages.map((entry) => entry.name));
+  return declared.filter((name) => !present.has(name));
+}
+
+// src/parsers/npm.ts
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+async function parseNpmLockfile(lockfilePath) {
+  let raw;
+  try {
+    raw = await readFile3(lockfilePath, "utf8");
+  } catch (cause) {
+    throw new PatchstackError(`Could not read lockfile at ${lockfilePath}`, "LOCKFILE_NOT_FOUND", cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new PatchstackError(`Lockfile at ${lockfilePath} is not valid JSON`, "LOCKFILE_PARSE_ERROR", cause);
+  }
+  if (parsed.packages) {
+    return extractFromV2(parsed.packages);
+  }
+  if (parsed.dependencies) {
+    return extractFromV1(parsed.dependencies);
+  }
+  throw new PatchstackError(
+    `Lockfile at ${lockfilePath} has no "packages" or "dependencies" key`,
+    "LOCKFILE_PARSE_ERROR"
+  );
+}
+function extractFromV2(packages) {
+  const entries = [];
+  for (const [pkgPath, pkg] of Object.entries(packages)) {
+    if (pkgPath === "") {
+      continue;
+    }
+    if (pkg.link === true) {
+      continue;
+    }
+    if (typeof pkg.version !== "string" || pkg.version.length === 0) {
+      continue;
+    }
+    const name = pkg.name ?? extractNameFromPath(pkgPath);
+    if (name === null) {
+      continue;
+    }
+    entries.push({
+      name,
+      version: pkg.version,
+      path: pkgPath,
+      direct: isDirectV2(pkgPath)
+    });
+  }
+  return entries;
+}
+function extractFromV1(deps, acc = [], depth = 0) {
+  for (const [name, dep] of Object.entries(deps)) {
+    if (typeof dep.version === "string" && dep.version.length > 0) {
+      acc.push({ name, version: dep.version, direct: depth === 0 });
+    }
+    if (dep.dependencies) {
+      extractFromV1(dep.dependencies, acc, depth + 1);
+    }
+  }
+  return acc;
+}
+function extractNameFromPath(pkgPath) {
+  const segments = pkgPath.split("node_modules" + path3.sep === pkgPath ? path3.sep : "/");
+  const parts = pkgPath.split("/");
+  const nmIndex = parts.lastIndexOf("node_modules");
+  if (nmIndex === -1 || nmIndex >= parts.length - 1) {
+    return segments[segments.length - 1] ?? null;
+  }
+  const tail = parts.slice(nmIndex + 1);
+  if (tail.length === 0) {
+    return null;
+  }
+  const first = tail[0];
+  if (first !== void 0 && first.startsWith("@") && tail.length >= 2) {
+    return `${first}/${tail[1]}`;
+  }
+  return first ?? null;
+}
+function isDirectV2(pkgPath) {
+  const parts = pkgPath.split("/");
+  const nmCount = parts.filter((p) => p === "node_modules").length;
+  return nmCount === 1;
+}
+
+// src/parsers/node_modules.ts
+import { lstat, readFile as readFile4, readdir, stat } from "fs/promises";
+import path4 from "path";
+async function walkNodeModules(cwd) {
+  const root = path4.join(cwd, "node_modules");
+  try {
+    const info = await stat(root);
+    if (!info.isDirectory()) {
+      throw new PatchstackError(
+        `${root} exists but is not a directory.`,
+        "LOCKFILE_NOT_FOUND"
+      );
+    }
+  } catch (cause) {
+    if (cause instanceof PatchstackError) {
+      throw cause;
+    }
+    throw new PatchstackError(
+      `node_modules/ not found at ${cwd}. Install dependencies first (e.g. \`bun install\` or \`npm install\`).`,
+      "LOCKFILE_NOT_FOUND",
+      cause
+    );
+  }
+  const entries = [];
+  await walk(root, entries, 0);
+  return entries;
+}
+async function walk(dir, acc, depth) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = path4.join(dir, name);
+    if (!await isPlainDirectory(fullPath)) {
+      continue;
+    }
+    if (name.startsWith("@")) {
+      let subNames;
+      try {
+        subNames = await readdir(fullPath);
+      } catch {
+        continue;
+      }
+      for (const sub of subNames) {
+        if (sub.startsWith(".")) {
+          continue;
+        }
+        const scopedDir = path4.join(fullPath, sub);
+        if (!await isPlainDirectory(scopedDir)) {
+          continue;
+        }
+        await readPackage(scopedDir, depth, acc);
+        await walkNested(scopedDir, acc, depth);
+      }
+      continue;
+    }
+    await readPackage(fullPath, depth, acc);
+    await walkNested(fullPath, acc, depth);
+  }
+}
+async function readPackage(pkgDir, depth, acc) {
+  let raw;
+  try {
+    raw = await readFile4(path4.join(pkgDir, "package.json"), "utf8");
+  } catch {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (typeof parsed.name !== "string" || parsed.name.length === 0) {
+    return;
+  }
+  if (typeof parsed.version !== "string" || parsed.version.length === 0) {
+    return;
+  }
+  acc.push({
+    name: parsed.name,
+    version: parsed.version,
+    direct: depth === 0
+  });
+}
+async function walkNested(pkgDir, acc, depth) {
+  const nested = path4.join(pkgDir, "node_modules");
+  if (!await isPlainDirectory(nested)) {
+    return;
+  }
+  await walk(nested, acc, depth + 1);
+}
+async function isPlainDirectory(dir) {
+  try {
+    const info = await lstat(dir);
+    return info.isDirectory() && !info.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// src/parsers/pnpm.ts
+import { readFile as readFile5 } from "fs/promises";
+async function parsePnpmLockfile(lockfilePath) {
+  let raw;
+  try {
+    raw = await readFile5(lockfilePath, "utf8");
+  } catch (cause) {
+    throw new PatchstackError(
+      `Could not read lockfile at ${lockfilePath}`,
+      "LOCKFILE_NOT_FOUND",
+      cause
+    );
+  }
+  const lines = raw.split(/\r?\n/);
+  const directNames = collectDirectDepNames(lines);
+  const packageKeys = collectPackagesBlockKeys(lines);
+  if (packageKeys.length === 0) {
+    throw new PatchstackError(
+      `Lockfile at ${lockfilePath} has no "packages" entries`,
+      "LOCKFILE_PARSE_ERROR"
+    );
+  }
+  const entries = [];
+  for (const key of packageKeys) {
+    const parsed = parsePackageKey(key);
+    if (parsed === null) {
+      continue;
+    }
+    entries.push({
+      name: parsed.name,
+      version: parsed.version,
+      direct: directNames.has(parsed.name)
+    });
+  }
+  return entries;
+}
+function parsePackageKey(rawKey) {
+  let k = rawKey.trim();
+  if (k.length === 0) {
+    return null;
+  }
+  if (k.startsWith("'") && k.endsWith("'") || k.startsWith('"') && k.endsWith('"')) {
+    k = k.slice(1, -1);
+  }
+  if (k.startsWith("/")) {
+    k = k.slice(1);
+  }
+  const parenIdx = k.indexOf("(");
+  if (parenIdx >= 0) {
+    k = k.slice(0, parenIdx);
+  }
+  let scopePrefix = "";
+  let body = k;
+  if (k.startsWith("@")) {
+    const firstSlash = k.indexOf("/");
+    if (firstSlash <= 0) {
+      return null;
+    }
+    scopePrefix = k.slice(0, firstSlash + 1);
+    body = k.slice(firstSlash + 1);
+  }
+  const slashIdx = body.indexOf("/");
+  const atIdx = body.indexOf("@");
+  let sepIdx;
+  if (slashIdx < 0 && atIdx < 0) {
+    return null;
+  } else if (slashIdx < 0) {
+    sepIdx = atIdx;
+  } else if (atIdx < 0) {
+    sepIdx = slashIdx;
+  } else {
+    sepIdx = Math.min(slashIdx, atIdx);
+  }
+  const name = scopePrefix + body.slice(0, sepIdx);
+  let version = body.slice(sepIdx + 1);
+  const underscoreIdx = version.indexOf("_");
+  if (underscoreIdx >= 0) {
+    version = version.slice(0, underscoreIdx);
+  }
+  if (name.length === 0 || version.length === 0) {
+    return null;
+  }
+  return { name, version };
+}
+function indentOf(line) {
+  let i = 0;
+  while (i < line.length && line[i] === " ") {
+    i++;
+  }
+  return i;
+}
+function isBlankOrComment(line) {
+  const trimmed = line.trim();
+  return trimmed.length === 0 || trimmed.startsWith("#");
+}
+function collectPackagesBlockKeys(lines) {
+  const keys = [];
+  let inBlock = false;
+  let childIndent = null;
+  for (const line of lines) {
+    if (isBlankOrComment(line)) {
+      continue;
+    }
+    const indent = indentOf(line);
+    if (!inBlock) {
+      if (indent === 0 && line.trim() === "packages:") {
+        inBlock = true;
+      }
+      continue;
+    }
+    if (indent === 0) {
+      break;
+    }
+    if (childIndent === null) {
+      childIndent = indent;
+    }
+    if (indent !== childIndent) {
+      continue;
+    }
+    const content = line.slice(indent);
+    if (!content.endsWith(":")) {
+      continue;
+    }
+    keys.push(content.slice(0, -1));
+  }
+  return keys;
+}
+function collectDirectDepNames(lines) {
+  const names = /* @__PURE__ */ new Set();
+  collectFromImporters(lines, names);
+  for (const section of ["dependencies", "devDependencies", "optionalDependencies"]) {
+    collectFromTopLevelSection(lines, section, names);
+  }
+  return names;
+}
+var DEP_SECTIONS = /* @__PURE__ */ new Set([
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies"
+]);
+function collectFromImporters(lines, out) {
+  let inImporters = false;
+  let importerIndent = null;
+  let inDepSection = false;
+  let depSectionIndent = null;
+  let leafIndent = null;
+  for (const line of lines) {
+    if (isBlankOrComment(line)) {
+      continue;
+    }
+    const indent = indentOf(line);
+    const trimmed = line.trim();
+    if (!inImporters) {
+      if (indent === 0 && trimmed === "importers:") {
+        inImporters = true;
+      }
+      continue;
+    }
+    if (indent === 0) {
+      break;
+    }
+    if (importerIndent === null) {
+      importerIndent = indent;
+    }
+    if (indent === importerIndent) {
+      inDepSection = false;
+      depSectionIndent = null;
+      leafIndent = null;
+      continue;
+    }
+    if (!inDepSection) {
+      const key = stripTrailingColon(trimmed);
+      if (key !== null && DEP_SECTIONS.has(key)) {
+        inDepSection = true;
+        depSectionIndent = indent;
+      }
+      continue;
+    }
+    if (depSectionIndent !== null && indent <= depSectionIndent) {
+      inDepSection = false;
+      depSectionIndent = null;
+      leafIndent = null;
+      const key = stripTrailingColon(trimmed);
+      if (key !== null && DEP_SECTIONS.has(key)) {
+        inDepSection = true;
+        depSectionIndent = indent;
+      }
+      continue;
+    }
+    if (leafIndent === null) {
+      leafIndent = indent;
+    }
+    if (indent !== leafIndent) {
+      continue;
+    }
+    const name = extractLeafName(trimmed);
+    if (name !== null) {
+      out.add(name);
+    }
+  }
+}
+function collectFromTopLevelSection(lines, section, out) {
+  let inSection = false;
+  let leafIndent = null;
+  for (const line of lines) {
+    if (isBlankOrComment(line)) {
+      continue;
+    }
+    const indent = indentOf(line);
+    const trimmed = line.trim();
+    if (!inSection) {
+      if (indent === 0 && trimmed === `${section}:`) {
+        inSection = true;
+      }
+      continue;
+    }
+    if (indent === 0) {
+      break;
+    }
+    if (leafIndent === null) {
+      leafIndent = indent;
+    }
+    if (indent !== leafIndent) {
+      continue;
+    }
+    const name = extractLeafName(trimmed);
+    if (name !== null) {
+      out.add(name);
+    }
+  }
+}
+function stripTrailingColon(s) {
+  if (!s.endsWith(":")) {
+    return null;
+  }
+  return s.slice(0, -1).trim();
+}
+function extractLeafName(trimmed) {
+  const colonIdx = trimmed.indexOf(":");
+  if (colonIdx < 0) {
+    return null;
+  }
+  let name = trimmed.slice(0, colonIdx).trim();
+  if (name.length === 0) {
+    return null;
+  }
+  if (name.startsWith("'") && name.endsWith("'") || name.startsWith('"') && name.endsWith('"')) {
+    name = name.slice(1, -1);
+  }
+  return name.length > 0 ? name : null;
+}
+
+// src/parsers/yarn.ts
+import { readFile as readFile6 } from "fs/promises";
+import path5 from "path";
+async function parseYarnLockfile(lockfilePath) {
+  let raw;
+  try {
+    raw = await readFile6(lockfilePath, "utf8");
+  } catch (cause) {
+    throw new PatchstackError(
+      `Could not read lockfile at ${lockfilePath}`,
+      "LOCKFILE_NOT_FOUND",
+      cause
+    );
+  }
+  const blocks = parseBlocks(raw);
+  if (blocks.length === 0) {
+    throw new PatchstackError(
+      `Lockfile at ${lockfilePath} contains no package entries`,
+      "LOCKFILE_PARSE_ERROR"
+    );
+  }
+  const directNames = await readDirectDepNames(path5.dirname(lockfilePath));
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (block.version.length === 0 || block.names.size === 0) {
+      continue;
+    }
+    for (const name of block.names) {
+      const dedupKey = `${name}@${block.version}`;
+      if (seen.has(dedupKey)) {
+        continue;
+      }
+      seen.add(dedupKey);
+      entries.push({
+        name,
+        version: block.version,
+        direct: directNames.has(name)
+      });
+    }
+  }
+  return entries;
+}
+function parseBlocks(raw) {
+  const lines = raw.split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+  const finalize = () => {
+    if (current !== null && current.version.length > 0 && current.names.size > 0) {
+      blocks.push(current);
+    }
+    current = null;
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) {
+      continue;
+    }
+    const indent = countLeadingSpaces(line);
+    if (indent === 0) {
+      finalize();
+      if (!trimmed.endsWith(":")) {
+        continue;
+      }
+      const keyLine = trimmed.slice(0, -1);
+      const names = /* @__PURE__ */ new Set();
+      for (const spec of splitDescriptors(keyLine)) {
+        const name = extractName(spec);
+        if (name !== null) {
+          names.add(name);
+        }
+      }
+      current = { names, version: "" };
+      continue;
+    }
+    if (current === null) {
+      continue;
+    }
+    const version = parseVersionField(trimmed);
+    if (version !== null) {
+      current.version = version;
+    }
+  }
+  finalize();
+  return blocks;
+}
+function countLeadingSpaces(line) {
+  let i = 0;
+  while (i < line.length && line[i] === " ") {
+    i++;
+  }
+  return i;
+}
+function splitDescriptors(keyLine) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < keyLine.length; i++) {
+    const c = keyLine[i];
+    if (quote !== null) {
+      current += c;
+      if (c === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      current += c;
+      continue;
+    }
+    if (c === ",") {
+      const piece = current.trim();
+      if (piece.length > 0) {
+        parts.push(piece);
+      }
+      current = "";
+      continue;
+    }
+    current += c;
+  }
+  const tail = current.trim();
+  if (tail.length > 0) {
+    parts.push(tail);
+  }
+  return parts;
+}
+function extractName(rawSpec) {
+  let s = rawSpec.trim();
+  if (s.length === 0) {
+    return null;
+  }
+  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
+    s = s.slice(1, -1);
+  }
+  const atIdx = s.lastIndexOf("@");
+  if (atIdx <= 0) {
+    return null;
+  }
+  const name = s.slice(0, atIdx);
+  return name.length > 0 ? name : null;
+}
+function parseVersionField(content) {
+  if (!content.startsWith("version")) {
+    return null;
+  }
+  const after = content.slice("version".length);
+  const firstChar = after.charAt(0);
+  if (firstChar !== " " && firstChar !== "	" && firstChar !== ":") {
+    return null;
+  }
+  let rest = firstChar === ":" ? after.slice(1) : after;
+  rest = rest.trim();
+  if (rest.length === 0) {
+    return null;
+  }
+  if (rest.startsWith('"') && rest.endsWith('"') || rest.startsWith("'") && rest.endsWith("'")) {
+    rest = rest.slice(1, -1);
+  }
+  return rest.length > 0 ? rest : null;
+}
+async function readDirectDepNames(cwd) {
+  const names = /* @__PURE__ */ new Set();
+  let raw;
+  try {
+    raw = await readFile6(path5.join(cwd, "package.json"), "utf8");
+  } catch {
+    return names;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return names;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return names;
+  }
+  const obj = parsed;
+  for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
+    const section = obj[field];
+    if (typeof section !== "object" || section === null) {
+      continue;
+    }
+    for (const name of Object.keys(section)) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+
+// src/parsers/index.ts
+var LOCKFILE_CANDIDATES = [
+  { filename: "package-lock.json", strategy: "npm-lockfile" },
+  { filename: "bun.lock", strategy: "node-modules-walk" },
+  { filename: "bun.lockb", strategy: "node-modules-walk" },
+  { filename: "pnpm-lock.yaml", strategy: "pnpm-lockfile" },
+  { filename: "yarn.lock", strategy: "yarn-lockfile" }
+];
+async function detectLockfile(cwd) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = path6.join(cwd, candidate.filename);
+      return { ...candidate, filePath, present: await exists(filePath) };
+    })
+  );
+  const match = probed.find((candidate) => candidate.present);
+  if (match) {
+    return {
+      ecosystem: "npm",
+      filePath: match.filePath,
+      filename: match.filename,
+      strategy: match.strategy
+    };
+  }
+  const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
+  throw new PatchstackError(
+    `No lockfile found in ${cwd}. Expected one of: ${expected}.`,
+    "LOCKFILE_NOT_FOUND"
+  );
+}
+async function scanLockfile(cwd) {
+  const candidates = await presentLockfiles(cwd);
+  if (candidates.length === 0) {
+    await detectLockfile(cwd);
+  }
+  const declared = await readDeclaredDependencyNames(cwd);
+  const warnings = [];
+  let firstParsed = null;
+  let walkTried = false;
+  for (const candidate of candidates) {
+    let packages;
+    try {
+      packages = await runStrategy(candidate, cwd);
+    } catch {
+      continue;
+    }
+    walkTried ||= candidate.strategy === "node-modules-walk";
+    firstParsed ??= { packages, filename: candidate.filename };
+    const missing = missingDependencies(declared, packages);
+    if (missing.length === 0) {
+      return manifestWith(packages, warnings);
+    }
+    warnings.push(staleWarning(candidate.filename, missing));
+  }
+  if (!walkTried) {
+    try {
+      const packages = await walkNodeModules(cwd);
+      const missing = missingDependencies(declared, packages);
+      if (missing.length > 0) {
+        warnings.push(staleWarning("node_modules/", missing));
+      }
+      warnings.push("Scanned node_modules/ instead. Delete the stale lockfile to silence this warning.");
+      return manifestWith(packages, warnings);
+    } catch {
+    }
+  }
+  if (firstParsed === null) {
+    const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
+    throw new PatchstackError(
+      `No readable lockfile found in ${cwd}. Expected one of: ${expected}.`,
+      "LOCKFILE_NOT_FOUND"
+    );
+  }
+  warnings.push(
+    `No fully-consistent source found; reporting ${firstParsed.filename}. The manifest may understate the real dependency set.`
+  );
+  return manifestWith(firstParsed.packages, warnings);
+}
+function manifestWith(packages, warnings) {
+  return warnings.length > 0 ? { ecosystem: "npm", packages, warnings } : { ecosystem: "npm", packages };
+}
+function staleWarning(source, missing) {
+  const sample = missing.slice(0, 3).join(", ");
+  const suffix = missing.length > 3 ? `, +${missing.length - 3} more` : "";
+  return `${source} looks stale: package.json declares ${missing.length} dependenc${missing.length === 1 ? "y" : "ies"} it does not contain (${sample}${suffix}).`;
+}
+async function presentLockfiles(cwd) {
+  const probed = await Promise.all(
+    LOCKFILE_CANDIDATES.map(async (candidate) => {
+      const filePath = path6.join(cwd, candidate.filename);
+      return { ...candidate, filePath, present: await exists(filePath) };
+    })
+  );
+  return probed.filter((candidate) => candidate.present).map(({ filename, strategy, filePath }) => ({ ecosystem: "npm", filename, strategy, filePath }));
+}
+async function runStrategy(detected, cwd) {
+  switch (detected.strategy) {
+    case "npm-lockfile":
+      return parseNpmLockfile(detected.filePath);
+    case "pnpm-lockfile":
+      return parsePnpmLockfile(detected.filePath);
+    case "yarn-lockfile":
+      return parseYarnLockfile(detected.filePath);
+    case "node-modules-walk":
+      return walkNodeModules(cwd);
+  }
+}
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/normalize.ts
+function buildWirePayload(manifest) {
+  const seen = /* @__PURE__ */ new Map();
+  const wirePackages = [];
+  for (const entry of manifest.packages) {
+    const versions = seen.get(entry.name);
+    if (versions) {
+      if (versions.has(entry.version)) {
+        continue;
+      }
+      versions.add(entry.version);
+    } else {
+      seen.set(entry.name, /* @__PURE__ */ new Set([entry.version]));
+    }
+    wirePackages.push({ name: entry.name, version: entry.version });
+  }
+  wirePackages.sort((a, b) => {
+    if (a.name === b.name) {
+      return compareVersions(a.version, b.version);
+    }
+    return a.name < b.name ? -1 : 1;
+  });
+  const duplicateNames = [];
+  for (const [name, versions] of seen) {
+    if (versions.size > 1) {
+      duplicateNames.push(name);
+    }
+  }
+  return {
+    payload: { ecosystem: manifest.ecosystem, packages: wirePackages },
+    stats: {
+      uniqueNames: seen.size,
+      duplicateNames,
+      totalEntries: manifest.packages.length
+    }
+  };
+}
+function compareVersions(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  const [aBase, aPre] = splitPrerelease(a);
+  const [bBase, bPre] = splitPrerelease(b);
+  const baseCmp = compareSegments(aBase.split("."), bBase.split("."));
+  if (baseCmp !== 0) {
+    return baseCmp;
+  }
+  if (aPre === null && bPre === null) {
+    return 0;
+  }
+  if (aPre === null) {
+    return 1;
+  }
+  if (bPre === null) {
+    return -1;
+  }
+  return compareSegments(aPre.split("."), bPre.split("."));
+}
+function splitPrerelease(version) {
+  const cleaned = version.replace(/^[v=]+/, "").split("+")[0];
+  const dashIndex = cleaned.indexOf("-");
+  if (dashIndex === -1) {
+    return [cleaned, null];
+  }
+  return [cleaned.slice(0, dashIndex), cleaned.slice(dashIndex + 1)];
+}
+function compareSegments(a, b) {
+  const max = Math.max(a.length, b.length);
+  for (let i = 0; i < max; i++) {
+    const aPart = a[i];
+    const bPart = b[i];
+    if (aPart === void 0) {
+      return -1;
+    }
+    if (bPart === void 0) {
+      return 1;
+    }
+    const aNum = /^\d+$/.test(aPart);
+    const bNum = /^\d+$/.test(bPart);
+    if (aNum && bNum) {
+      const diff = Number(aPart) - Number(bPart);
+      if (diff !== 0) {
+        return diff < 0 ? -1 : 1;
+      }
+      continue;
+    }
+    if (aNum) {
+      return -1;
+    }
+    if (bNum) {
+      return 1;
+    }
+    if (aPart < bPart) {
+      return -1;
+    }
+    if (aPart > bPart) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+// src/protect/refresh-manifest.ts
+async function reportManifest(cwd) {
+  const config = await resolveConfig({ cwd });
+  if (config.siteUuid === null || config.siteUuid.length === 0) {
+    return;
+  }
+  const manifest = await scanLockfile(cwd);
+  const { payload } = buildWirePayload(manifest);
+  await postManifest(config, payload);
+}
+export {
+  reportManifest
+};
+//# sourceMappingURL=refresh-manifest-XBOGN446.js.map