gutterpress 0.0.0

package/dist/cli-hvqjs342.js

@@ -0,0 +1,284 @@
+// package.json
+var package_default = {
+  name: "gutterpress",
+  version: "0.0.0",
+  description: "Markdown-to-PDF converter for professional print layout using Paged.js and Ghostscript.",
+  author: "itlackey",
+  license: "MPL-2.0",
+  keywords: [
+    "markdown",
+    "pdf",
+    "print",
+    "pagedjs",
+    "ghostscript",
+    "book",
+    "publishing",
+    "ttrpg"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/dimm-city/gutterpress.git"
+  },
+  homepage: "https://github.com/dimm-city/gutterpress#readme",
+  bugs: {
+    url: "https://github.com/dimm-city/gutterpress/issues"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    gutterpress: "./dist/cli.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./api": {
+      types: "./dist/api/index.d.ts",
+      default: "./dist/api/index.js"
+    },
+    "./render": {
+      types: "./dist/render.d.ts",
+      default: "./dist/render.js"
+    }
+  },
+  files: [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    "build:library": "rimraf dist && bun build src/index.ts src/api/index.ts --target=node --packages=external --splitting --outdir=dist && bun build src/render.ts --target=node --packages=external --outdir=dist && node scripts/check-render-pure.mjs && tsc -p tsconfig.build.json",
+    build: "bun run build:library && bun build src/cli.ts --target=node --packages=external --splitting --outdir=dist",
+    prepublishOnly: "bun run build",
+    test: "bun test",
+    typecheck: "tsc --noEmit"
+  },
+  engines: {
+    bun: ">=1.0.0",
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    acorn: "8.16.0",
+    chokidar: "^5.0.0",
+    citty: "^0.2.0",
+    diff3: "0.0.3",
+    "es-module-lexer": "2.0.0",
+    fflate: "0.8.3",
+    glob: "^13.0.0",
+    htmlhint: "^1.9.2",
+    "isomorphic-git": "^1.38.4",
+    "markdown-it": "^14.1.0",
+    "markdown-it-abbr": "^2.0.0",
+    "markdown-it-attrs": "^4.3.0",
+    "markdown-it-deflist": "^3.0.1",
+    "markdown-it-footnote": "^4.0.0",
+    "markdown-it-mark": "^4.0.0",
+    "markdown-it-source-map": "^0.1.1",
+    "markdown-it-sub": "^2.0.0",
+    "markdown-it-sup": "^2.0.0",
+    markdownlint: "^0.40.0",
+    "pdf-lib": "^1.17.1",
+    postcss: "^8.5.18",
+    "puppeteer-core": "^25.0.4",
+    "resolve.exports": "2.0.3",
+    semver: "7.8.0",
+    tar: "7.5.20",
+    unpdf: "^1.6.2",
+    ws: "^8.21.0",
+    yaml: "^2.8.2"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^22.0.0",
+    "@types/semver": "^7.7.1",
+    "@types/ws": "^8.5.13",
+    pagedjs: "^0.4.3",
+    playwright: "^1.60.0",
+    rimraf: "^6.0.0",
+    typescript: "^5"
+  }
+};
+
+// src/lib/build-error.ts
+var EXIT_CODES = {
+  OK: 0,
+  FINDINGS: 1,
+  USAGE: 2,
+  PIPELINE: 3
+};
+
+class BuildError extends Error {
+  exitCode;
+  constructor(message, exitCode = EXIT_CODES.PIPELINE, options) {
+    super(message, options);
+    this.name = "BuildError";
+    this.exitCode = exitCode;
+  }
+}
+
+// src/constants.ts
+var NETWORK = {
+  DEFAULT_PORT: 3579
+};
+var DEBOUNCE = {
+  FILE_WATCH: 100
+};
+
+// src/lib/cli-args.ts
+class UsageError extends Error {
+  exitCode;
+  constructor(message, exitCode = EXIT_CODES.USAGE) {
+    super(message);
+    this.name = "UsageError";
+    this.exitCode = exitCode;
+  }
+}
+function camelCaseFlag(name) {
+  return name.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function kebabCaseFlag(name) {
+  return name.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+function takesValue(definition) {
+  return definition.type === "string" || definition.type === "enum";
+}
+function rejectUnknownFlags(rawArgs, declared, commandName) {
+  const longFlags = new Map;
+  const shortFlags = new Map;
+  for (const [name, definition] of Object.entries(declared)) {
+    if (definition.type === "positional")
+      continue;
+    for (const variant of new Set([
+      name,
+      camelCaseFlag(name),
+      kebabCaseFlag(name)
+    ])) {
+      longFlags.set(variant, definition);
+    }
+    const aliases = Array.isArray(definition.alias) ? definition.alias : definition.alias ? [definition.alias] : [];
+    for (const alias of aliases) {
+      longFlags.set(alias, definition);
+      if (alias.length === 1)
+        shortFlags.set(alias, definition);
+    }
+    if (name.length === 1)
+      shortFlags.set(name, definition);
+  }
+  const reject = (option) => {
+    throw new UsageError(`gutterpress ${commandName}: unknown option ${option}`);
+  };
+  const missingValue = (option) => {
+    throw new UsageError(`gutterpress ${commandName}: option ${option} requires a value`);
+  };
+  const isDeclaredOptionBoundary = (token) => {
+    if (token === "--" || token === "--help" || token === "-h")
+      return true;
+    if (token.startsWith("--")) {
+      const rawName = token.slice(2).split("=", 1)[0];
+      const directDefinition = longFlags.get(rawName);
+      if (directDefinition)
+        return true;
+      if (!rawName.startsWith("no-"))
+        return false;
+      return longFlags.get(rawName.slice(3))?.type === "boolean";
+    }
+    return token.startsWith("-") && token.length > 1 && shortFlags.has(token[1]);
+  };
+  const consumeValue = (index, option) => {
+    const value = rawArgs[index + 1];
+    if (value === undefined || isDeclaredOptionBoundary(value)) {
+      missingValue(option);
+    }
+    return index + 1;
+  };
+  for (let i = 0;i < rawArgs.length; i++) {
+    const token = rawArgs[i];
+    if (token === "--")
+      break;
+    if (token === "--help" || token === "-h" || token === "-")
+      continue;
+    if (token.startsWith("--")) {
+      const equalsAt = token.indexOf("=");
+      const option = equalsAt === -1 ? token : token.slice(0, equalsAt);
+      const rawName = option.slice(2);
+      const directDefinition = longFlags.get(rawName);
+      const negated = !directDefinition && rawName.startsWith("no-");
+      const name = negated ? rawName.slice(3) : rawName;
+      const definition = directDefinition ?? longFlags.get(name);
+      if (!definition)
+        throw new UsageError(`gutterpress ${commandName}: unknown option ${option}`);
+      if (negated && (definition.type !== "boolean" || equalsAt !== -1))
+        reject(option);
+      if (!negated && takesValue(definition)) {
+        if (equalsAt === -1) {
+          i = consumeValue(i, option);
+        } else if (token.slice(equalsAt + 1).length === 0) {
+          missingValue(option);
+        }
+      }
+      continue;
+    }
+    if (!token.startsWith("-") || token.length === 1)
+      continue;
+    const body = token.slice(1);
+    for (let j = 0;j < body.length; j++) {
+      const alias = body[j];
+      const definition = shortFlags.get(alias);
+      if (!definition)
+        throw new UsageError(`gutterpress ${commandName}: unknown option ${token}`);
+      if (takesValue(definition)) {
+        const attached = body.slice(j + 1);
+        if (attached.length === 0) {
+          i = consumeValue(i, `-${alias}`);
+        } else if (attached === "=") {
+          missingValue(`-${alias}`);
+        }
+        break;
+      }
+    }
+  }
+}
+function rejectExtraPositionals(positionals, expectedCount, commandName) {
+  const extras = (positionals ?? []).slice(expectedCount);
+  if (extras.length > 0) {
+    throw new UsageError(`gutterpress ${commandName}: unexpected extra argument(s): ${extras.join(" ")}`);
+  }
+}
+function parseFormat(raw, opts) {
+  if (raw === undefined)
+    return opts.default;
+  if (raw === "")
+    throw new UsageError("--format requires a value.");
+  if (raw === "html" || raw === "pdf" || raw === "pdfx")
+    return raw;
+  throw new UsageError(`Invalid --format value: "${raw}". Expected "html", "pdf", or "pdfx".`);
+}
+function parsePdfxFlavor(raw, format) {
+  if (raw === undefined)
+    return;
+  if (raw === "")
+    throw new UsageError("--pdfx-flavor requires a value.");
+  if (format !== "pdfx") {
+    throw new UsageError(`--pdfx-flavor is only valid with --format pdfx (got --format ${format}).`);
+  }
+  if (raw === "x1a" || raw === "x3")
+    return raw;
+  throw new UsageError(`Invalid --pdfx-flavor value: "${raw}". Expected "x1a" or "x3".`);
+}
+function resolvePort(raw) {
+  if (raw === undefined)
+    return NETWORK.DEFAULT_PORT;
+  if (raw === "" || typeof raw === "string" && raw.trim() === "") {
+    throw new UsageError("--port requires a value.");
+  }
+  const n = typeof raw === "number" || typeof raw === "string" ? Number(raw) : NaN;
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0 || n > 65535) {
+    throw new UsageError(`Invalid --port value: "${raw}". Expected an integer from 0 to 65535 (0 = OS-assigned).`);
+  }
+  return n;
+}
+
+export { package_default, DEBOUNCE, EXIT_CODES, BuildError, UsageError, rejectUnknownFlags, rejectExtraPositionals, parseFormat, parsePdfxFlavor, resolvePort };

package/dist/cli-yja077f6.js

@@ -0,0 +1,92 @@
+// src/lib/remote-auth/git-http.ts
+import httpNode from "isomorphic-git/http/node";
+var GIT_HTTP_IDLE_TIMEOUT_MS = 60000;
+var GIT_HTTP_UPLOAD_TIMEOUT_MS = 30 * 60000;
+var SMALL_BODY_MAX_BYTES = 256 * 1024;
+function isSmallBody(body) {
+  if (!Array.isArray(body))
+    return false;
+  let total = 0;
+  for (const c of body) {
+    const size = c?.byteLength;
+    if (typeof size !== "number")
+      return false;
+    total += size;
+  }
+  return total <= SMALL_BODY_MAX_BYTES;
+}
+function gitTimeoutError(what, ms) {
+  return new Error(`Git network operation timed out after ${Math.round(ms / 1000)}s (${what}); ` + `couldn't reach the remote (ETIMEDOUT).`);
+}
+function withIdleTimeout(http, idleMs = GIT_HTTP_IDLE_TIMEOUT_MS, uploadMs = GIT_HTTP_UPLOAD_TIMEOUT_MS) {
+  return {
+    async request(options) {
+      let timer;
+      let trip;
+      const tripped = new Promise((_, reject) => {
+        trip = reject;
+      });
+      tripped.catch(() => {});
+      const arm = (ms, what) => {
+        if (timer)
+          clearTimeout(timer);
+        timer = setTimeout(() => trip(gitTimeoutError(what, ms)), ms);
+        timer.unref?.();
+      };
+      const disarm = () => {
+        if (timer)
+          clearTimeout(timer);
+        timer = undefined;
+      };
+      const race = (p) => Promise.race([p, tripped]).catch((e) => {
+        p.catch(() => {});
+        throw e;
+      });
+      const body = options.body;
+      const isLargeUpload = body != null && !isSmallBody(body);
+      arm(isLargeUpload ? uploadMs : idleMs, isLargeUpload ? "the upload did not complete" : "the remote did not respond");
+      let res;
+      try {
+        res = await race(http.request(options));
+      } finally {
+        disarm();
+      }
+      const rawBody = res.body;
+      if (!rawBody || typeof rawBody[Symbol.asyncIterator] !== "function") {
+        return res;
+      }
+      const source = rawBody[Symbol.asyncIterator]();
+      const guardedBody = {
+        async next() {
+          arm(idleMs, "the remote stopped sending data");
+          try {
+            const step = await race(source.next());
+            disarm();
+            return step;
+          } catch (e) {
+            disarm();
+            try {
+              Promise.resolve(source.return?.()).catch(() => {});
+            } catch {}
+            throw e;
+          }
+        },
+        return(value) {
+          disarm();
+          try {
+            return Promise.resolve(source.return?.(value) ?? { done: true, value: undefined });
+          } catch {
+            return Promise.resolve({ done: true, value: undefined });
+          }
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+      return { ...res, body: guardedBody };
+    }
+  };
+}
+var defaultGitHttp = withIdleTimeout(httpNode);
+
+export { GIT_HTTP_IDLE_TIMEOUT_MS, GIT_HTTP_UPLOAD_TIMEOUT_MS, SMALL_BODY_MAX_BYTES, isSmallBody, withIdleTimeout, defaultGitHttp };

package/dist/cli.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import {
+  previewArgs
+} from "./cli-506tg37g.js";
+import {
+  EXIT_CODES,
+  UsageError,
+  package_default,
+  rejectUnknownFlags
+} from "./cli-hvqjs342.js";
+import {
+  __require
+} from "./cli-37x76zdn.js";
+
+// src/cli.ts
+import { defineCommand, parseArgs, runMain } from "citty";
+import { statSync } from "node:fs";
+var SUBCOMMANDS = {
+  new: () => import("./new-7b08a42h.js").then((m) => m.default),
+  preview: () => import("./preview-h2bwbb2x.js").then((m) => m.default),
+  build: () => import("./build-5s92kgpc.js").then((m) => m.default),
+  publish: () => import("./publish-ztaet53r.js").then((m) => m.default),
+  lint: () => import("./lint-f63nxjfj.js").then((m) => m.default),
+  validate: () => import("./validate-k2drs19j.js").then((m) => m.default),
+  audit: () => import("./audit-1jrwwacz.js").then((m) => m.default),
+  preflight: () => import("./preflight-tg4mpz1h.js").then((m) => m.default),
+  repair: () => import("./repair-jkp4n3j8.js").then((m) => m.default),
+  doctor: () => import("./doctor-25zjt8dz.js").then((m) => m.default),
+  plugin: () => import("./plugin-wf2cbmwc.js").then((m) => m.default)
+};
+var VERSION = package_default.version;
+var main = defineCommand({
+  meta: {
+    name: "gutterpress",
+    version: VERSION,
+    description: "Markdown to print-ready PDF (and static-site HTML) using Chromium + Paged.js"
+  },
+  setup({ rawArgs }) {
+    return preflightRequiredInvocations(rawArgs);
+  },
+  subCommands: SUBCOMMANDS
+});
+function exitUsage(error) {
+  if (error instanceof UsageError) {
+    console.error(error.message);
+    process.exit(error.exitCode);
+  }
+  throw error;
+}
+async function preflightRequiredInvocations(rawArgs) {
+  const [command, ...commandArgs] = rawArgs;
+  try {
+    if (command === "new") {
+      const { newArgs } = await import("./new-7b08a42h.js");
+      rejectUnknownFlags(commandArgs, newArgs, "new");
+      const parsed2 = parseArgs(commandArgs, {
+        ...newArgs,
+        name: { ...newArgs.name, required: false }
+      });
+      if (parsed2.name === undefined) {
+        throw new UsageError("gutterpress new: missing required positional argument NAME");
+      }
+      return;
+    }
+    if (command === "preflight") {
+      const { preflightArgs } = await import("./preflight-tg4mpz1h.js");
+      rejectUnknownFlags(commandArgs, preflightArgs, "preflight");
+      const parsed2 = parseArgs(commandArgs, {
+        ...preflightArgs,
+        pdf: { ...preflightArgs.pdf, required: false }
+      });
+      if (parsed2.pdf === undefined) {
+        throw new UsageError("gutterpress preflight: missing required argument --pdf");
+      }
+      return;
+    }
+    if (command !== "plugin")
+      return;
+    const [subcommand, ...subcommandArgs] = commandArgs;
+    if (subcommand === undefined)
+      return;
+    if (subcommand === "--" || subcommand === "-") {
+      throw new UsageError(`gutterpress plugin: expected a subcommand before ${subcommand}`);
+    }
+    if (subcommand.startsWith("-"))
+      return;
+    if (subcommand !== "add") {
+      throw new UsageError(`gutterpress plugin: unknown command "${subcommand}"`);
+    }
+    const { pluginAddArgs } = await import("./plugin-wf2cbmwc.js");
+    rejectUnknownFlags(subcommandArgs, pluginAddArgs, "plugin add");
+    const parsed = parseArgs(subcommandArgs, {
+      ...pluginAddArgs,
+      package: { ...pluginAddArgs.package, required: false }
+    });
+    if (parsed.package === undefined) {
+      throw new UsageError("gutterpress plugin add: missing required positional argument PACKAGE");
+    }
+  } catch (error) {
+    exitUsage(error);
+  }
+}
+function isDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function editDistance(left, right) {
+  let previous = Array.from({ length: right.length + 1 }, (_, i) => i);
+  for (let i = 1;i <= left.length; i++) {
+    const current = [i];
+    for (let j = 1;j <= right.length; j++) {
+      current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
+    }
+    previous = current;
+  }
+  return previous[right.length];
+}
+function closestSubcommand(input) {
+  const commands = Object.keys(SUBCOMMANDS);
+  const closest = commands.map((command) => ({ command, distance: editDistance(input, command) })).sort((a, b) => a.distance - b.distance)[0];
+  if (!closest)
+    return;
+  return closest.distance <= Math.max(2, Math.floor(input.length / 3)) ? closest.command : undefined;
+}
+function resolveImplicitPreview(rawArgs) {
+  try {
+    rejectUnknownFlags(rawArgs, previewArgs, "preview");
+  } catch {
+    return { usePreview: true };
+  }
+  const positional = parseArgs(rawArgs, previewArgs)._[0];
+  return positional === undefined || isDirectory(positional) ? { usePreview: true } : { usePreview: false, unknownCommand: positional };
+}
+var rawArgs = process.argv.slice(2);
+if (rawArgs.length === 1 && rawArgs[0] === "plugin")
+  rawArgs.push("--help");
+var wantsHelp = rawArgs.includes("--help") || rawArgs.includes("-h");
+var wantsVersion = rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v");
+var firstArg = rawArgs[0];
+var isKnownSubcommand = firstArg !== undefined && firstArg in SUBCOMMANDS;
+var shouldRun = true;
+if (!wantsHelp && !wantsVersion && !isKnownSubcommand) {
+  const implicit = resolveImplicitPreview(rawArgs);
+  if (implicit.usePreview) {
+    rawArgs.unshift("preview");
+  } else {
+    const suggestion = closestSubcommand(implicit.unknownCommand);
+    console.error(`Unknown command "${implicit.unknownCommand}".` + (suggestion ? ` Did you mean "${suggestion}"?` : ` Run "gutterpress --help" to see available commands.`));
+    process.exitCode = EXIT_CODES.USAGE;
+    shouldRun = false;
+  }
+}
+if (shouldRun)
+  runMain(main, { rawArgs });

package/dist/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Application-wide constants
+ */
+/**
+ * Network-related constants
+ */
+export declare const NETWORK: {
+    /** Default port for preview server */
+    readonly DEFAULT_PORT: 3579;
+};
+/**
+ * Debounce delays in milliseconds
+ */
+export declare const DEBOUNCE: {
+    /** Debounce delay for file watch events */
+    readonly FILE_WATCH: 100;
+};

package/dist/doctor-25zjt8dz.js

@@ -0,0 +1,57 @@
+import {
+  getSystemDiagnostics,
+  log
+} from "./cli-h7phg3ka.js";
+import {
+  UsageError,
+  rejectExtraPositionals,
+  rejectUnknownFlags
+} from "./cli-hvqjs342.js";
+import"./cli-37x76zdn.js";
+
+// src/commands/doctor.ts
+import { defineCommand } from "citty";
+var commandArgs = {};
+var doctor_default = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Check system tools used by Gutterpress"
+  },
+  args: commandArgs,
+  async run({ args, rawArgs }) {
+    try {
+      rejectUnknownFlags(rawArgs, commandArgs, "doctor");
+      rejectExtraPositionals(args._, 0, "doctor");
+      const diagnostics = await getSystemDiagnostics();
+      console.log(`gutterpress ${diagnostics.libVersion}`);
+      console.log(`System: ${diagnostics.platform.os} ${diagnostics.platform.arch} ` + `(${diagnostics.platform.release}), Node ${diagnostics.platform.node}`);
+      console.log(`Config: ${diagnostics.configDir}`);
+      console.log("");
+      console.log("Tools:");
+      for (const tool of diagnostics.tools) {
+        const version = tool.version ? `, ${tool.version}` : "";
+        console.log(`  [${tool.found ? "ok" : "missing"}] ${tool.name} (${tool.bin}${version})`);
+        if (tool.path)
+          console.log(`    Path: ${tool.path}`);
+        console.log(`    Used by: ${tool.usedBy.map((use) => use.feature).join(", ")}`);
+        if (!tool.found) {
+          console.log("    Install:");
+          for (const line of tool.installHint.split(/\r?\n/)) {
+            console.log(`      ${line}`);
+          }
+        }
+      }
+      console.log("");
+      console.log(`Setup guide: ${diagnostics.docsUrl}`);
+    } catch (error) {
+      if (error instanceof UsageError) {
+        log.error(error.message);
+        process.exit(error.exitCode);
+      }
+      throw error;
+    }
+  }
+});
+export {
+  doctor_default as default
+};

package/dist/git-http-yrb4ag6z.js

@@ -0,0 +1,17 @@
+import {
+  GIT_HTTP_IDLE_TIMEOUT_MS,
+  GIT_HTTP_UPLOAD_TIMEOUT_MS,
+  SMALL_BODY_MAX_BYTES,
+  defaultGitHttp,
+  isSmallBody,
+  withIdleTimeout
+} from "./cli-yja077f6.js";
+import"./cli-37x76zdn.js";
+export {
+  withIdleTimeout,
+  isSmallBody,
+  defaultGitHttp,
+  SMALL_BODY_MAX_BYTES,
+  GIT_HTTP_UPLOAD_TIMEOUT_MS,
+  GIT_HTTP_IDLE_TIMEOUT_MS
+};