blume 1.6.4 → 1.6.6

package/dist/cli/chunk-cbjnx4s8.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+// src/core/probe.ts
+import pMap from "p-map";
+var PROBE_CONCURRENCY = 8;
+var PROBE_TIMEOUT_MS = 1e4;
+var STATUS_NOT_FOUND = 404;
+var STATUS_GONE = 410;
+var STATUS_METHOD_NOT_ALLOWED = 405;
+var STATUS_NOT_IMPLEMENTED = 501;
+var request = async (url, method, timeoutMs) => {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const started = performance.now();
+  try {
+    const response = await fetch(url, {
+      method,
+      redirect: "follow",
+      signal: controller.signal
+    });
+    return {
+      encoding: response.headers.get("content-encoding"),
+      finalUrl: response.url,
+      ms: Math.round(performance.now() - started),
+      ok: response.ok,
+      redirected: response.redirected,
+      robotsTag: response.headers.get("x-robots-tag"),
+      status: response.status
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return { ok: false, timedOut: true };
+    }
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      ok: false
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var probe = async (url, options = {}) => {
+  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;
+  const head = await request(url, "HEAD", timeoutMs);
+  const unreachable = !head.ok && head.status === undefined && !head.timedOut;
+  const retry = head.status === STATUS_METHOD_NOT_ALLOWED || head.status === STATUS_NOT_IMPLEMENTED || unreachable;
+  return retry ? await request(url, "GET", timeoutMs) : head;
+};
+var gradeExternal = (result) => {
+  if (result.ok) {
+    return null;
+  }
+  if (result.timedOut) {
+    return { detail: "request timed out", severity: "warning" };
+  }
+  if (result.status === undefined) {
+    return { detail: result.error ?? "unreachable", severity: "error" };
+  }
+  if (result.status === STATUS_NOT_FOUND || result.status === STATUS_GONE) {
+    return { detail: `HTTP ${result.status}`, severity: "error" };
+  }
+  return { detail: `HTTP ${result.status}`, severity: "warning" };
+};
+var probeAll = async (urls, options = {}) => {
+  const unique = [...new Set(urls)];
+  const entries = await pMap(unique, async (url) => [url, await probe(url, options)], { concurrency: Math.max(1, options.concurrency ?? PROBE_CONCURRENCY) });
+  return new Map(entries);
+};
+
+export { gradeExternal, probeAll };
+
+//# debugId=A29226CDC8AC5EB464756E2164756E21
+//# sourceMappingURL=chunk-cbjnx4s8.js.map

package/dist/cli/chunk-cbjnx4s8.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/core/probe.ts"],
+  "sourcesContent": [
+    "import pMap from \"p-map\";\n\nimport type { DiagnosticSeverity } from \"./types.ts\";\n\nexport const PROBE_CONCURRENCY = 8;\nexport const PROBE_TIMEOUT_MS = 10_000;\n\nconst STATUS_NOT_FOUND = 404;\nconst STATUS_GONE = 410;\nconst STATUS_METHOD_NOT_ALLOWED = 405;\nconst STATUS_NOT_IMPLEMENTED = 501;\n\n/** The outcome of a single HTTP probe, with failures normalized rather than thrown. */\nexport interface ProbeResult {\n  ok: boolean;\n  status?: number;\n  timedOut?: boolean;\n  error?: string;\n  /** Whether the request was redirected before landing on `status`. */\n  redirected?: boolean;\n  /** The URL finally landed on, after following redirects. */\n  finalUrl?: string;\n  /** `Content-Encoding` of the response, when the server set one. */\n  encoding?: string | null;\n  /** Wall-clock milliseconds for the request. */\n  ms?: number;\n  /** `X-Robots-Tag` of the response, when the server set one. */\n  robotsTag?: string | null;\n}\n\n/** Probe a URL with the given method, normalizing failures to a result. */\nconst request = async (\n  url: string,\n  method: \"GET\" | \"HEAD\",\n  timeoutMs: number\n): Promise<ProbeResult> => {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  const started = performance.now();\n  try {\n    const response = await fetch(url, {\n      method,\n      redirect: \"follow\",\n      signal: controller.signal,\n    });\n    return {\n      encoding: response.headers.get(\"content-encoding\"),\n      finalUrl: response.url,\n      ms: Math.round(performance.now() - started),\n      ok: response.ok,\n      redirected: response.redirected,\n      robotsTag: response.headers.get(\"x-robots-tag\"),\n      status: response.status,\n    };\n  } catch (error) {\n    if (error instanceof Error && error.name === \"AbortError\") {\n      return { ok: false, timedOut: true };\n    }\n    return {\n      error: error instanceof Error ? error.message : String(error),\n      ok: false,\n    };\n  } finally {\n    clearTimeout(timer);\n  }\n};\n\n/**\n * Probe a single URL: HEAD first, falling back to GET.\n *\n * Plenty of servers reject HEAD outright (405/501) or drop the connection, so a\n * HEAD-only probe would report healthy pages as dead.\n */\nexport const probe = async (\n  url: string,\n  options: { timeoutMs?: number } = {}\n): Promise<ProbeResult> => {\n  const timeoutMs = options.timeoutMs ?? PROBE_TIMEOUT_MS;\n  const head = await request(url, \"HEAD\", timeoutMs);\n  const unreachable = !head.ok && head.status === undefined && !head.timedOut;\n  const retry =\n    head.status === STATUS_METHOD_NOT_ALLOWED ||\n    head.status === STATUS_NOT_IMPLEMENTED ||\n    unreachable;\n  return retry ? await request(url, \"GET\", timeoutMs) : head;\n};\n\n/** Grade a probe result into a severity + detail, or null when the URL is fine. */\nexport const gradeExternal = (\n  result: ProbeResult\n): { severity: DiagnosticSeverity; detail: string } | null => {\n  if (result.ok) {\n    return null;\n  }\n  if (result.timedOut) {\n    return { detail: \"request timed out\", severity: \"warning\" };\n  }\n  if (result.status === undefined) {\n    return { detail: result.error ?? \"unreachable\", severity: \"error\" };\n  }\n  // A 404/410 is definitively dead. A 403/429/5xx may well be rate limiting or a\n  // transient blip, which is not the author's bug to fix.\n  if (result.status === STATUS_NOT_FOUND || result.status === STATUS_GONE) {\n    return { detail: `HTTP ${result.status}`, severity: \"error\" };\n  }\n  return { detail: `HTTP ${result.status}`, severity: \"warning\" };\n};\n\n/**\n * Probe many URLs with bounded concurrency, deduplicating first. Returns a map\n * from URL to its result — the caller decides what each one means.\n */\nexport const probeAll = async (\n  urls: readonly string[],\n  options: { concurrency?: number; timeoutMs?: number } = {}\n): Promise<Map<string, ProbeResult>> => {\n  const unique = [...new Set(urls)];\n  const entries = await pMap(\n    unique,\n    async (url) => [url, await probe(url, options)] as const,\n    { concurrency: Math.max(1, options.concurrency ?? PROBE_CONCURRENCY) }\n  );\n  return new Map(entries);\n};\n"
+  ],
+  "mappings": ";;;AAAA;AAIO,IAAM,oBAAoB;AAC1B,IAAM,mBAAmB;AAEhC,IAAM,mBAAmB;AACzB,IAAM,cAAc;AACpB,IAAM,4BAA4B;AAClC,IAAM,yBAAyB;AAqB/B,IAAM,UAAU,OACd,KACA,QACA,cACyB;AAAA,EACzB,MAAM,aAAa,IAAI;AAAA,EACvB,MAAM,QAAQ,WAAW,MAAM,WAAW,MAAM,GAAG,SAAS;AAAA,EAC5D,MAAM,UAAU,YAAY,IAAI;AAAA,EAChC,IAAI;AAAA,IACF,MAAM,WAAW,MAAM,MAAM,KAAK;AAAA,MAChC;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,WAAW;AAAA,IACrB,CAAC;AAAA,IACD,OAAO;AAAA,MACL,UAAU,SAAS,QAAQ,IAAI,kBAAkB;AAAA,MACjD,UAAU,SAAS;AAAA,MACnB,IAAI,KAAK,MAAM,YAAY,IAAI,IAAI,OAAO;AAAA,MAC1C,IAAI,SAAS;AAAA,MACb,YAAY,SAAS;AAAA,MACrB,WAAW,SAAS,QAAQ,IAAI,cAAc;AAAA,MAC9C,QAAQ,SAAS;AAAA,IACnB;AAAA,IACA,OAAO,OAAO;AAAA,IACd,IAAI,iBAAiB,SAAS,MAAM,SAAS,cAAc;AAAA,MACzD,OAAO,EAAE,IAAI,OAAO,UAAU,KAAK;AAAA,IACrC;AAAA,IACA,OAAO;AAAA,MACL,OAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAAA,MAC5D,IAAI;AAAA,IACN;AAAA,YACA;AAAA,IACA,aAAa,KAAK;AAAA;AAAA;AAUf,IAAM,QAAQ,OACnB,KACA,UAAkC,CAAC,MACV;AAAA,EACzB,MAAM,YAAY,QAAQ,aAAa;AAAA,EACvC,MAAM,OAAO,MAAM,QAAQ,KAAK,QAAQ,SAAS;AAAA,EACjD,MAAM,cAAc,CAAC,KAAK,MAAM,KAAK,WAAW,aAAa,CAAC,KAAK;AAAA,EACnE,MAAM,QACJ,KAAK,WAAW,6BAChB,KAAK,WAAW,0BAChB;AAAA,EACF,OAAO,QAAQ,MAAM,QAAQ,KAAK,OAAO,SAAS,IAAI;AAAA;AAIjD,IAAM,gBAAgB,CAC3B,WAC4D;AAAA,EAC5D,IAAI,OAAO,IAAI;AAAA,IACb,OAAO;AAAA,EACT;AAAA,EACA,IAAI,OAAO,UAAU;AAAA,IACnB,OAAO,EAAE,QAAQ,qBAAqB,UAAU,UAAU;AAAA,EAC5D;AAAA,EACA,IAAI,OAAO,WAAW,WAAW;AAAA,IAC/B,OAAO,EAAE,QAAQ,OAAO,SAAS,eAAe,UAAU,QAAQ;AAAA,EACpE;AAAA,EAGA,IAAI,OAAO,WAAW,oBAAoB,OAAO,WAAW,aAAa;AAAA,IACvE,OAAO,EAAE,QAAQ,QAAQ,OAAO,UAAU,UAAU,QAAQ;AAAA,EAC9D;AAAA,EACA,OAAO,EAAE,QAAQ,QAAQ,OAAO,UAAU,UAAU,UAAU;AAAA;AAOzD,IAAM,WAAW,OACtB,MACA,UAAwD,CAAC,MACnB;AAAA,EACtC,MAAM,SAAS,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC;AAAA,EAChC,MAAM,UAAU,MAAM,KACpB,QACA,OAAO,QAAQ,CAAC,KAAK,MAAM,MAAM,KAAK,OAAO,CAAC,GAC9C,EAAE,aAAa,KAAK,IAAI,GAAG,QAAQ,eAAe,iBAAiB,EAAE,CACvE;AAAA,EACA,OAAO,IAAI,IAAI,OAAO;AAAA;",
+  "debugId": "A29226CDC8AC5EB464756E2164756E21",
+  "names": []
+}

package/dist/cli/chunk-cnvm6k3e.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import {
+  ensureGitignore
+} from "./chunk-5hs6gb7n.js";
+import {
+  prepareProject
+} from "./chunk-nyqzjdhj.js";
+import"./chunk-9sh49q0h.js";
+import"./chunk-btfr9yvw.js";
+import {
+  refuseIfDevRunning
+} from "./chunk-tc89yh2r.js";
+import"./chunk-62qsssnh.js";
+import"./chunk-n4qjabmt.js";
+import"./chunk-pxj10x8y.js";
+import"./chunk-sbdqrjbb.js";
+import"./chunk-5yvt556e.js";
+import"./chunk-ev67ycx0.js";
+import"./chunk-vt8fgygt.js";
+import"./chunk-3r94j3tc.js";
+import"./chunk-aerwpe14.js";
+import"./chunk-3k0kzs6d.js";
+import"./chunk-vxv4x1n8.js";
+import"./chunk-wd27zjcz.js";
+import"./chunk-etsqspj6.js";
+import"./chunk-vv3f8mb6.js";
+import"./chunk-27gtm2ym.js";
+import"./chunk-4xyggvgf.js";
+import"./chunk-6kzzpsx8.js";
+import {
+  logger
+} from "./chunk-ey89bjj1.js";
+import {
+  commandMeta
+} from "./chunk-2aj8ddew.js";
+
+// src/cli/commands/check.ts
+import { existsSync } from "node:fs";
+import { check } from "@astrojs/check";
+import { sync } from "astro";
+import { defineCommand } from "citty";
+import { join } from "pathe";
+var checkCommand = defineCommand({
+  args: {
+    isolated: {
+      description: "Type-check in an isolated .blume-verify runtime so a running dev server is untouched. For verifying changes while `blume dev` runs.",
+      type: "boolean"
+    },
+    preview: {
+      description: "Include drafts and unpublished CMS content.",
+      type: "boolean"
+    },
+    strict: {
+      description: "Fail on content diagnostics as well as type errors.",
+      type: "boolean"
+    }
+  },
+  meta: commandMeta.check,
+  async run({ args }) {
+    const root = process.cwd();
+    const runtimeDir = args.isolated ? ".blume-verify" : process.env.BLUME_RUNTIME_DIR;
+    refuseIfDevRunning(root, "checking", { isolatedHint: true, runtimeDir });
+    if (args.isolated) {
+      await ensureGitignore(root, [".blume-verify/"]);
+    }
+    const project = await prepareProject({
+      mode: "build",
+      preview: args.preview,
+      root,
+      runtimeDir,
+      strict: args.strict
+    });
+    const { outDir } = project.context;
+    await sync({ logLevel: "warn", root: outDir });
+    const tsconfig = join(root, "tsconfig.json");
+    logger.start(`Type-checking ${project.graph.pages.length} page(s)`);
+    const failed = await check({
+      minimumFailingSeverity: "error",
+      minimumSeverity: "hint",
+      root: outDir,
+      tsconfig: existsSync(tsconfig) ? tsconfig : undefined,
+      watch: false
+    });
+    if (failed) {
+      logger.error("Type check failed.");
+      process.exit(1);
+    }
+    logger.success("No type errors.");
+  }
+});
+export {
+  checkCommand
+};
+
+//# debugId=3E921ABECB33B7AC64756E2164756E21
+//# sourceMappingURL=chunk-cnvm6k3e.js.map

package/dist/cli/chunk-cnvm6k3e.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/cli/commands/check.ts"],
+  "sourcesContent": [
+    "import { existsSync } from \"node:fs\";\n\nimport { check } from \"@astrojs/check\";\nimport { sync } from \"astro\";\nimport { defineCommand } from \"citty\";\nimport { join } from \"pathe\";\n\nimport { ensureGitignore } from \"../../core/gitignore.ts\";\nimport { commandMeta } from \"../command-meta.ts\";\nimport { refuseIfDevRunning } from \"../dev-lock.ts\";\nimport { logger } from \"../log.ts\";\nimport { prepareProject } from \"../prepare.ts\";\n\nexport const checkCommand = defineCommand({\n  args: {\n    isolated: {\n      description:\n        \"Type-check in an isolated .blume-verify runtime so a running dev server is untouched. For verifying changes while `blume dev` runs.\",\n      type: \"boolean\",\n    },\n    preview: {\n      description: \"Include drafts and unpublished CMS content.\",\n      type: \"boolean\",\n    },\n    strict: {\n      description: \"Fail on content diagnostics as well as type errors.\",\n      type: \"boolean\",\n    },\n  },\n  meta: commandMeta.check,\n  async run({ args }) {\n    const root = process.cwd();\n\n    // `blume check` regenerates `.blume` just like `build`, so it must refuse a\n    // live dev server unless isolated. `--isolated` (or BLUME_RUNTIME_DIR)\n    // relocates the runtime to `.blume-verify`, which dev never locks.\n    const runtimeDir = args.isolated\n      ? \".blume-verify\"\n      : process.env.BLUME_RUNTIME_DIR;\n    refuseIfDevRunning(root, \"checking\", { isolatedHint: true, runtimeDir });\n    if (args.isolated) {\n      await ensureGitignore(root, [\".blume-verify/\"]);\n    }\n\n    const project = await prepareProject({\n      mode: \"build\",\n      preview: args.preview,\n      root,\n      runtimeDir,\n      strict: args.strict,\n    });\n\n    const { outDir } = project.context;\n\n    // Generate Astro's content/collection and font types into `.blume/.astro`\n    // so `astro:*` virtual modules resolve during the check.\n    await sync({ logLevel: \"warn\", root: outDir });\n\n    // The project-root tsconfig is what covers the authored `pages/` and config;\n    // without it astro check only sees the generated `.blume` project. Falls back\n    // to the generated project's own tsconfig when the project has none.\n    const tsconfig = join(root, \"tsconfig.json\");\n\n    logger.start(`Type-checking ${project.graph.pages.length} page(s)`);\n    const failed = await check({\n      minimumFailingSeverity: \"error\",\n      minimumSeverity: \"hint\",\n      root: outDir,\n      tsconfig: existsSync(tsconfig) ? tsconfig : undefined,\n      watch: false,\n    });\n\n    if (failed) {\n      logger.error(\"Type check failed.\");\n      process.exit(1);\n    }\n\n    logger.success(\"No type errors.\");\n  },\n});\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAEA;AACA;AACA;AACA;AAQO,IAAM,eAAe,cAAc;AAAA,EACxC,MAAM;AAAA,IACJ,UAAU;AAAA,MACR,aACE;AAAA,MACF,MAAM;AAAA,IACR;AAAA,IACA,SAAS;AAAA,MACP,aAAa;AAAA,MACb,MAAM;AAAA,IACR;AAAA,IACA,QAAQ;AAAA,MACN,aAAa;AAAA,MACb,MAAM;AAAA,IACR;AAAA,EACF;AAAA,EACA,MAAM,YAAY;AAAA,OACZ,IAAG,GAAG,QAAQ;AAAA,IAClB,MAAM,OAAO,QAAQ,IAAI;AAAA,IAKzB,MAAM,aAAa,KAAK,WACpB,kBACA,QAAQ,IAAI;AAAA,IAChB,mBAAmB,MAAM,YAAY,EAAE,cAAc,MAAM,WAAW,CAAC;AAAA,IACvE,IAAI,KAAK,UAAU;AAAA,MACjB,MAAM,gBAAgB,MAAM,CAAC,gBAAgB,CAAC;AAAA,IAChD;AAAA,IAEA,MAAM,UAAU,MAAM,eAAe;AAAA,MACnC,MAAM;AAAA,MACN,SAAS,KAAK;AAAA,MACd;AAAA,MACA;AAAA,MACA,QAAQ,KAAK;AAAA,IACf,CAAC;AAAA,IAED,QAAQ,WAAW,QAAQ;AAAA,IAI3B,MAAM,KAAK,EAAE,UAAU,QAAQ,MAAM,OAAO,CAAC;AAAA,IAK7C,MAAM,WAAW,KAAK,MAAM,eAAe;AAAA,IAE3C,OAAO,MAAM,iBAAiB,QAAQ,MAAM,MAAM,gBAAgB;AAAA,IAClE,MAAM,SAAS,MAAM,MAAM;AAAA,MACzB,wBAAwB;AAAA,MACxB,iBAAiB;AAAA,MACjB,MAAM;AAAA,MACN,UAAU,WAAW,QAAQ,IAAI,WAAW;AAAA,MAC5C,OAAO;AAAA,IACT,CAAC;AAAA,IAED,IAAI,QAAQ;AAAA,MACV,OAAO,MAAM,oBAAoB;AAAA,MACjC,QAAQ,KAAK,CAAC;AAAA,IAChB;AAAA,IAEA,OAAO,QAAQ,iBAAiB;AAAA;AAEpC,CAAC;",
+  "debugId": "3E921ABECB33B7AC64756E2164756E21",
+  "names": []
+}