gutterpress 0.0.0

package/dist/checks/pdf/image-resolution.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/index.d.ts

@@ -0,0 +1,15 @@
+import "./qpdf-structure";
+import "./page-size";
+import "./pdfx-markers";
+import "./color-spaces";
+import "./embedded-fonts";
+import "./ink-coverage";
+import "./rasterized-pages";
+import "./bookmarks";
+import "./toc-links";
+import "./cross-refs";
+import "./page-labels";
+import "./image-resolution";
+import "./transparency";
+import "./bleed";
+import "./pdfx-metadata";

package/dist/checks/pdf/ink-coverage.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/page-labels.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/page-size.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/pdfx-markers.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/pdfx-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/pdfx-structure.d.ts

@@ -0,0 +1,6 @@
+type PdfxFlavor = "x1a" | "x3";
+type JsonObject = Record<string, unknown>;
+export declare function parseQpdfObjectsJson(stdout: string): JsonObject | null;
+export declare function getPdfxOutputIntentIssues(objects: JsonObject): string[];
+export declare function getPdfxMetadataIssues(objects: JsonObject, flavor: PdfxFlavor): string[];
+export {};

package/dist/checks/pdf/qpdf-structure.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/rasterized-pages.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/toc-links.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/pdf/transparency.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/policy.d.ts

@@ -0,0 +1,61 @@
+import type { Check, CheckCategory, CheckPhase, CheckResult } from "./types";
+import type { ResolvedConfig } from "../schema/manifest.types";
+/**
+ * Machine-readable `code` marking a result produced by an inspection / tool
+ * FAILURE (we could not parse or probe the artifact) — as opposed to a genuine
+ * content violation. The report layer can branch on this without parsing prose.
+ */
+export declare const INSPECT_FAILED_CODE = "inspect-failed";
+/**
+ * The single source of truth for whether a check runs under a given config.
+ * Used by BOTH the runner (execution) and tool-check (tool probing) so the two
+ * can never drift.
+ *
+ * Order: an explicit manifest disable wins first, then the check's own
+ * declarative `enabledWhen(config)` predicate — the canonical, per-check way to
+ * express a tool-specific config gate (e.g. `source.stylelint === false`)
+ * instead of hard-coding special cases in the runner/tool-check.
+ */
+export declare function isCheckEnabled(check: Check, config: ResolvedConfig): boolean;
+/** Selector inputs shared by check execution and tool probing. */
+export interface CheckSelectionOptions {
+    only?: string[];
+    skip?: string[];
+    category?: CheckCategory | CheckCategory[];
+    phase?: CheckPhase;
+}
+export interface CheckSelection {
+    checks: Check[];
+    /** Selectors (from `only`/`skip`) that matched no registered check. */
+    unmatched: string[];
+}
+/**
+ * The check-selection sequence shared by {@link runChecks} and
+ * {@link checkToolAvailability} (audit E10): resolve `only`/`skip` selectors,
+ * then drop manifest-disabled checks via {@link isCheckEnabled}. Extracted so
+ * the two callers can never disagree on WHICH checks are in scope — previously
+ * this exact three-step sequence was hand-copied in both, kept in sync only by
+ * a comment. Returns `unmatched` selectors so each caller decides whether to
+ * surface them (the runner errors on them; tool probing deliberately ignores
+ * them to avoid double-warning).
+ */
+export declare function selectChecks(opts: CheckSelectionOptions, config: ResolvedConfig): CheckSelection;
+/**
+ * Build a genuine finding, injecting the check id. Severity/message/etc. are the
+ * caller's configured values — this represents a real content violation, so its
+ * severity is honoured (and can be overridden by the manifest).
+ */
+export declare function finding(checkId: string, init: Omit<CheckResult, "checkId">): CheckResult;
+/**
+ * Build the result for an inspection / tool FAILURE — a missing tool, an
+ * unreadable file, or malformed inspector output. Policy: always a single
+ * `warning` tagged `code: "inspect-failed"`, never a hard `error` and never
+ * silently dropped, so a transient failure is neither invisible nor
+ * build-breaking. Use `finding()` for genuine violations instead.
+ */
+export declare function inspectionFailed(checkId: string, message: string, extra?: {
+    file?: string;
+    line?: number;
+    detail?: string;
+    data?: Record<string, unknown>;
+}): CheckResult;

package/dist/checks/register-builtins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Central registration of the built-in checks (audit B5).
+ *
+ * The check registry (registry.ts) is a module-level Map populated purely as a
+ * side effect of importing each category's index module. Those four imports
+ * previously lived only in `lib/validation-exec.ts`, so `runChecks`/`getChecks`
+ * reached any other way (a direct import of `checks/runner`, a reordering of the
+ * package entry's re-exports) would see an EMPTY registry and silently validate
+ * nothing. Importing THIS module makes the registry self-populating regardless
+ * of who the first caller is; `runner.ts` imports it at load, so anything that
+ * can reach `runChecks` has already registered the built-ins. ESM evaluates a
+ * module once, so importing this from several places registers exactly once.
+ */
+import "./pdf/index";
+import "./source/index";
+import "./asset/index";
+import "./heuristic/index";

package/dist/checks/registry.d.ts

@@ -0,0 +1,40 @@
+import type { Check, CheckCategory, CheckPhase } from "./types";
+/**
+ * Register a check in the process-global registry.
+ *
+ * Returns an unregister function so temporary registrations (tests, mainly)
+ * can remove themselves — the registry is a module-level Map shared by every
+ * caller in the process, so a leaked throwaway check would silently run in
+ * every later unfiltered `runChecks`. The returned function is idempotent and
+ * only removes the exact check it registered (a later re-registration under
+ * the same id is left untouched). Built-in check modules ignore the return
+ * value; they register once at import and live for the process.
+ */
+export declare function registerCheck(check: Check): () => void;
+export interface CheckFilter {
+    category?: CheckCategory | CheckCategory[];
+    phase?: CheckPhase;
+    ids?: string[];
+}
+export declare function getChecks(filter?: CheckFilter): Check[];
+export declare function getCheckById(id: string): Check | undefined;
+export declare function getAllCheckIds(): string[];
+/**
+ * The set of `CheckCategory` values actually in use by registered checks.
+ * Derived from the registry (rather than a hand-maintained literal list) so
+ * it can never drift from `CheckCategory`'s real members — used to validate
+ * `--category` input against something other than a bare `as CheckCategory`
+ * cast, which previously accepted any string.
+ */
+export declare function getKnownCategories(): CheckCategory[];
+export interface ResolvedSelectors {
+    /** Check IDs matched by the selectors (deduplicated, in match order). */
+    resolved: string[];
+    /**
+     * Selectors that matched no registered check — almost always a typo. Callers
+     * MUST surface these; a mistyped `--only`/`--skip` selector silently dropped
+     * would otherwise resolve to nothing and report a false "PASSED".
+     */
+    unmatched: string[];
+}
+export declare function resolveCheckSelectors(selectors: string[]): ResolvedSelectors;

package/dist/checks/runner.d.ts

@@ -0,0 +1,25 @@
+import type { CheckCategory, CheckContext, CheckPhase, CheckResult } from "./types";
+import "./register-builtins";
+export interface RunnerOptions {
+    category?: CheckCategory[];
+    phase?: CheckPhase;
+    only?: string[];
+    skip?: string[];
+    /** Check IDs to skip due to missing tools (set by tool-check) */
+    skipMissingTools?: string[];
+}
+export interface RunnerReport {
+    results: CheckResult[];
+    errors: CheckResult[];
+    warnings: CheckResult[];
+    infos: CheckResult[];
+    passed: string[];
+    summary: {
+        total: number;
+        errors: number;
+        warnings: number;
+        infos: number;
+        passed: number;
+    };
+}
+export declare function runChecks(ctx: CheckContext, opts?: RunnerOptions): Promise<RunnerReport>;

package/dist/checks/source/accessibility-alt-text.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/source/accessibility-heading-order.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/source/config-file.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Locate a lint config file for a source check. An explicit relative path
+ * (from the check's manifest config) wins when it exists; otherwise the first
+ * of `names` found in the input dir is used. Returns null when nothing
+ * matches. Shared by the markdownlint and htmlhint wrappers so their
+ * config-discovery rules can never drift.
+ */
+export declare function findConfigFile(inputDir: string, names: readonly string[], explicit?: string | null): string | null;

package/dist/checks/source/htmlhint.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/source/index.d.ts

@@ -0,0 +1,6 @@
+import "./markdownlint";
+import "./htmlhint";
+import "./stylelint";
+import "./local-refs";
+import "./accessibility-alt-text";
+import "./accessibility-heading-order";

package/dist/checks/source/local-refs.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/source/markdownlint.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/source/stylelint.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "../types";
+declare const check: Check;
+export default check;

package/dist/checks/tool-check.d.ts

@@ -0,0 +1,23 @@
+import "./register-builtins";
+import type { ResolvedConfig } from "../schema/manifest.types";
+import type { RunnerOptions } from "./runner";
+export interface ToolCheckResult {
+    /** Tools that were checked and found present */
+    available: string[];
+    /** Tools that are missing */
+    missing: string[];
+    /** Check IDs that will be skipped due to missing tools */
+    skippedChecks: string[];
+    /** Mapping: missing tool → check IDs that need it */
+    toolToChecks: Map<string, string[]>;
+}
+/**
+ * Checks whether external tools required by active checks are installed.
+ * Skips tools whose only dependent checks are explicitly disabled in the manifest.
+ * Returns which tools are missing and which checks will be skipped.
+ */
+export declare function checkToolAvailability(config: ResolvedConfig, opts?: RunnerOptions): Promise<ToolCheckResult>;
+/**
+ * Log warnings for missing tools, showing which checks will be skipped.
+ */
+export declare function reportMissingTools(result: ToolCheckResult): void;

package/dist/checks/types.d.ts

@@ -0,0 +1,52 @@
+import type { ResolvedConfig } from "../schema/manifest.types";
+export type CheckSeverity = "error" | "warning" | "info";
+export type CheckCategory = "source" | "pdf" | "asset" | "heuristic";
+export type CheckPhase = "pre-build" | "post-build";
+export interface CheckResult {
+    checkId: string;
+    severity: CheckSeverity;
+    message: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    detail?: string;
+    /**
+     * Stable machine-readable identifier for the KIND of finding (e.g.
+     * "ink-coverage-exceeded", "rasterized-pages-detected"). Lets the report /
+     * summary layer branch on the finding without parsing `message` prose.
+     */
+    code?: string;
+    /**
+     * Structured payload for the finding (e.g. `{ maxTac, pages }`). The canonical
+     * source for summary numbers — `message`/`detail` are for humans only.
+     */
+    data?: Record<string, unknown>;
+}
+export interface CheckContext {
+    config: ResolvedConfig;
+    inputDir: string;
+    outputDir: string;
+    pdfPath?: string;
+    htmlPath?: string;
+    markdownFiles?: string[];
+    cssFiles?: string[];
+    assetDirs?: string[];
+}
+export interface Check {
+    id: string;
+    name: string;
+    description: string;
+    category: CheckCategory;
+    phase: CheckPhase;
+    /** External CLI tools this check requires (e.g. ["qpdf", "pdfinfo"]) */
+    requiredTools?: string[];
+    /**
+     * Declarative enable gate driven by config (beyond the generic
+     * `validate.checks[id]` enable/disable). Lets a check own a tool-specific
+     * config switch — e.g. `source.stylelint === false` — so the runner and
+     * tool-check never need per-check special cases. Returning `false` disables
+     * the check for enablement/tool-probing purposes.
+     */
+    enabledWhen?: (config: ResolvedConfig) => boolean;
+    run(ctx: CheckContext): Promise<CheckResult[]>;
+}

package/dist/cli-1tyj4bk3.js

@@ -0,0 +1,124 @@
+// src/lib/project-source.ts
+import * as fs from "node:fs";
+import { stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import git from "isomorphic-git";
+function pickSyncRemote(remotes) {
+  return remotes.find((r) => r.remote === "origin") ?? remotes[0];
+}
+async function syncRemoteFor(dir) {
+  try {
+    const remotes = await git.listRemotes({ fs, dir });
+    const picked = pickSyncRemote(remotes);
+    if (picked?.url)
+      return picked;
+  } catch {}
+  try {
+    const url = await git.getConfig({ fs, dir, path: "remote.origin.url" });
+    if (url)
+      return { remote: "origin", url };
+  } catch {}
+  return;
+}
+async function gitEntryKind(dir) {
+  try {
+    const s = await stat(path.join(dir, ".git"));
+    return s.isDirectory() ? "dir" : "file";
+  } catch {
+    return "none";
+  }
+}
+async function findEnclosingRepoDir(folderPath) {
+  const home = path.resolve(os.homedir());
+  let dir = path.resolve(folderPath);
+  for (let i = 0;i < 64; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+    if (dir === home)
+      return;
+    if (await gitEntryKind(dir) !== "none")
+      return dir;
+  }
+  return;
+}
+async function readRepoInfo(dir) {
+  const remoteUrl = (await syncRemoteFor(dir))?.url;
+  let branch;
+  try {
+    branch = await git.currentBranch({ fs, dir }) || undefined;
+  } catch {
+    branch = undefined;
+  }
+  return { remoteUrl, branch };
+}
+function repoSubPath(repoRoot, folderPath) {
+  const rel = path.relative(path.resolve(repoRoot), path.resolve(folderPath));
+  return rel.split(path.sep).join("/");
+}
+async function detectProjectSource(folderPath) {
+  if (await gitEntryKind(folderPath) !== "none") {
+    const { remoteUrl, branch } = await readRepoInfo(folderPath);
+    return {
+      type: "local-git-folder",
+      path: folderPath,
+      repoRoot: folderPath,
+      subPath: "",
+      hasRemote: remoteUrl !== undefined,
+      ...remoteUrl !== undefined ? { remoteUrl } : {},
+      ...branch !== undefined ? { branch } : {}
+    };
+  }
+  const enclosingRepoDir = await findEnclosingRepoDir(folderPath);
+  if (enclosingRepoDir !== undefined) {
+    const { remoteUrl, branch } = await readRepoInfo(enclosingRepoDir);
+    return {
+      type: "local-git-folder",
+      path: folderPath,
+      repoRoot: enclosingRepoDir,
+      subPath: repoSubPath(enclosingRepoDir, folderPath),
+      hasRemote: remoteUrl !== undefined,
+      ...remoteUrl !== undefined ? { remoteUrl } : {},
+      ...branch !== undefined ? { branch } : {}
+    };
+  }
+  return { type: "local-folder", path: folderPath };
+}
+function capabilitiesFor(source) {
+  switch (source.type) {
+    case "local-folder":
+      return {
+        canRead: true,
+        canWriteLocal: true,
+        canEnableVersionHistory: true,
+        canSnapshot: false,
+        canViewHistory: false,
+        canRestoreSnapshot: false,
+        authManagedByApp: false
+      };
+    case "local-git-folder":
+      return {
+        canRead: true,
+        canWriteLocal: true,
+        canEnableVersionHistory: false,
+        canSnapshot: true,
+        canViewHistory: true,
+        canRestoreSnapshot: true,
+        authManagedByApp: false
+      };
+    case "managed-github":
+      return {
+        canRead: true,
+        canWriteLocal: true,
+        canEnableVersionHistory: false,
+        canSnapshot: true,
+        canViewHistory: true,
+        canRestoreSnapshot: true,
+        authManagedByApp: true
+      };
+  }
+}
+
+export { pickSyncRemote, syncRemoteFor, findEnclosingRepoDir, repoSubPath, detectProjectSource, capabilitiesFor };

package/dist/cli-37x76zdn.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/cli-506tg37g.js

@@ -0,0 +1,26 @@
+// src/commands/preview-args.ts
+var previewArgs = {
+  input: { type: "positional", description: "Input markdown directory (defaults to current directory)", required: false },
+  format: { type: "string", description: "Output format: html (default, live HMR) | pdf | pdfx" },
+  port: { type: "string", description: "Port number (default: 3579, html only)" },
+  host: { type: "string", description: "Bind host (default: 127.0.0.1). Pass 0.0.0.0 to expose on the LAN." },
+  watch: {
+    type: "boolean",
+    default: true,
+    description: "Watch files for changes (html only)",
+    negativeDescription: "Disable file watching (html only)"
+  },
+  open: { type: "boolean", default: true, description: "Automatically open browser/desktop (default: true; use --no-open to skip)" },
+  verbose: { type: "boolean", description: "Enable verbose output" },
+  debug: { type: "boolean", description: "Debug mode (preserve temporary files)" },
+  out: { type: "string", description: "Output directory (pdf|pdfx only)" },
+  "pdfx-flavor": { type: "string", description: "PDF/X flavor (x1a or x3); only with --format pdfx" },
+  icc: { type: "string", description: "Path to ICC profile (required for --format pdfx)" },
+  manifest: { type: "string", description: "Path to manifest.yaml (pdf|pdfx only)" },
+  "strip-annotations": { type: "boolean", description: "Strip PDF annotations for PDF/X compliance (pdfx only)" },
+  "skip-lint": { type: "boolean", description: "Skip CSS linting (pdf|pdfx only)" },
+  "skip-pre-validate": { type: "boolean", description: "Skip pre-build validation (pdf|pdfx only)" },
+  "skip-post-validate": { type: "boolean", description: "Skip post-build PDF/X validation (pdfx only)" }
+};
+
+export { previewArgs };