gutterpress 0.0.0

package/dist/preview/lifecycle.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Server lifecycle management
+ *
+ * Handles startup, restart, shutdown, and client connection tracking.
+ * Uses the simplified manifest + config pipeline from lib/manifest.
+ */
+import type { ResolvedConfig } from '../schema/manifest.types';
+import type { ServerState } from './server-context';
+/**
+ * Initialize the preview's temp directory.
+ *
+ * SERVE-IN-PLACE (this replaces the old whole-tree `copyDirectory(inputPath,
+ * tempDir)` + manifest-asset `copyAssets` call): the temp dir is no longer a
+ * mirror of the project. It holds ONLY files gutterpress itself generates — right
+ * now that's `book.html` (written later by {@link generateAndWriteHtml}) and
+ * the PID marker file below. Every other path the served HTML asks for
+ * (images, anything else under the project) is read straight from the
+ * project directory by the HTTP server (see http-server.ts) — the project is
+ * never copied anywhere.
+ *
+ * This is what makes preview asset resolution identical to the build's BY
+ * CONSTRUCTION: both read the same real files off the same real project tree,
+ * so there is no separate copy step that can drift from what a build actually
+ * ships (the "works in preview, broken in the PDF" bug class). It also means
+ * a project's `.env`, `.git`, or any other dotfile is never duplicated into a
+ * world-readable temp dir the way the old whole-tree copy did — see
+ * http-server.ts's dotfile guard, which is what stands between a request and
+ * the project's real dotfiles now that the project is served directly.
+ *
+ * No longer takes `inputPath`/`config` — both were needed only for the copy
+ * steps removed above, and there is nothing left to configure here.
+ */
+export declare function initializePreviewDirectories(): Promise<string>;
+/**
+ * Validate that the input path exists on the filesystem.
+ * No-op for empty input (no-input mode — the desktop desktop app
+ * supplies the path via its own folder picker).
+ */
+export declare function validateInputPath(inputPath: string): Promise<void>;
+/**
+ * Initialize configuration by loading manifest and resolving config.
+ * For empty input (no-input mode), skip manifest loading entirely and
+ * return a default resolved config.
+ */
+export declare function initializeConfiguration(inputPath: string): Promise<ResolvedConfig>;
+/**
+ * Restart the preview server with a new input directory.
+ *
+ * SERVE-IN-PLACE makes this trivially correct where the old copy-based
+ * version was not: the HTTP server (http-server.ts) reads `state.
+ * currentInputPath` fresh on every request instead of serving a stale mirror,
+ * so repointing that one field IS the switch — there is no per-project copy
+ * to redo, and therefore no old project's files left behind in the (now
+ * shared-nothing, generated-files-only) temp dir the way the previous
+ * `copyDirectory(newInputPath, state.tempDir)` could leave a stale mix of two
+ * projects' content if it partially failed.
+ */
+export declare function restartPreview(newInputPath: string, state: ServerState): Promise<void>;
+/**
+ * Perform graceful server shutdown and cleanup.
+ *
+ * Each step runs independently so that a hang or throw in one (e.g.
+ * `previewServer.close()` blocking on a stuck WebSocket client) cannot
+ * prevent the temp-dir from being removed. Without this discipline,
+ * SIGTERM during a wedged close leaks ~1GB of `/tmp` per session.
+ */
+export declare function shutdownServer(state: ServerState): Promise<void>;

package/dist/preview/server-context.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Preview server context and state management
+ */
+import type { FSWatcher } from 'chokidar';
+import type { PreviewServerOptions } from '../types';
+import type { ResolvedConfig } from '../schema/manifest.types';
+import type { PreviewServer } from './http-server';
+/**
+ * Server lifecycle state
+ */
+export interface ServerState {
+    /** Current input directory being previewed */
+    currentInputPath: string;
+    /** File watcher instance */
+    currentWatcher: FSWatcher | null;
+    /** Pending debounced rebuild timer scheduled by the file watcher */
+    rebuildTimer: NodeJS.Timeout | null;
+    /** Is currently rebuilding? (prevents overlapping builds) */
+    isRebuilding: boolean;
+    /** Active rebuild, awaited before a project restart closes its watcher. */
+    rebuildPromise?: Promise<void> | null;
+    /** node:http + `ws` preview HTTP/WebSocket server instance */
+    previewServer: PreviewServer | null;
+    /** Is server shutting down? (prevents multiple shutdown calls) */
+    isShuttingDown: boolean;
+    /** Temporary directory for preview files */
+    tempDir: string;
+    /** Resolved configuration */
+    config: ResolvedConfig;
+    /** Server options */
+    options: PreviewServerOptions;
+}
+/**
+ * Create initial server state
+ */
+export declare function createServerState(inputPath: string, tempDir: string, config: ResolvedConfig, options: PreviewServerOptions): ServerState;

package/dist/preview-h2bwbb2x.js

@@ -0,0 +1,102 @@
+import {
+  previewArgs
+} from "./cli-506tg37g.js";
+import {
+  openPath,
+  runBuild,
+  splitOutPath,
+  startPreviewServer
+} from "./cli-7ykx7pp0.js";
+import {
+  log
+} from "./cli-h7phg3ka.js";
+import {
+  BuildError,
+  UsageError,
+  parseFormat,
+  parsePdfxFlavor,
+  rejectExtraPositionals,
+  rejectUnknownFlags,
+  resolvePort
+} from "./cli-hvqjs342.js";
+import"./cli-5bxx0c4y.js";
+import"./cli-1tyj4bk3.js";
+import"./cli-yja077f6.js";
+import"./cli-37x76zdn.js";
+
+// src/commands/preview.ts
+import { defineCommand } from "citty";
+import path from "node:path";
+import fs from "node:fs";
+var preview_default = defineCommand({
+  meta: { name: "preview", description: "Live HTML preview with HMR (default), or one-shot build + open for --format pdf|pdfx" },
+  args: previewArgs,
+  async run({ args, rawArgs }) {
+    try {
+      rejectUnknownFlags(rawArgs, previewArgs, "preview");
+      rejectExtraPositionals(args._, 1, "preview");
+      const format = parseFormat(args.format, { default: "html" });
+      log.info(`Format: ${format}`);
+      const inputPath = args.input ? path.resolve(args.input) : undefined;
+      if (inputPath !== undefined) {
+        if (!fs.existsSync(inputPath) || !fs.statSync(inputPath).isDirectory()) {
+          throw new UsageError(`Input directory does not exist: ${inputPath}`);
+        }
+      }
+      const openFlag = args.open;
+      if (format === "html") {
+        if (typeof args.manifest === "string") {
+          throw new UsageError("--manifest is only supported by preview --format pdf or pdfx; live HTML preview discovers the project manifest from its input directory.");
+        }
+        await startPreviewServer({
+          input: inputPath,
+          port: resolvePort(args.port),
+          host: args.host || "127.0.0.1",
+          noWatch: args.watch === false,
+          verbose: !!args.verbose,
+          openBrowser: openFlag,
+          debug: !!args.debug
+        });
+        return;
+      }
+      if (inputPath === undefined) {
+        throw new UsageError(`--format ${format} requires an input directory.`);
+      }
+      const pdfxFlavor = parsePdfxFlavor(args["pdfx-flavor"], format);
+      const { outDir, pdfFileOverride } = splitOutPath(typeof args.out === "string" ? args.out : undefined, format);
+      const result = await runBuild({
+        inputDir: inputPath,
+        format,
+        outDir,
+        pdfFileOverride,
+        pdfxFlavor,
+        iccPath: typeof args.icc === "string" ? args.icc : undefined,
+        manifestPath: typeof args.manifest === "string" ? args.manifest : undefined,
+        stripAnnotations: typeof args["strip-annotations"] === "boolean" ? args["strip-annotations"] : undefined,
+        skipLint: !!args["skip-lint"],
+        skipPreValidate: !!args["skip-pre-validate"],
+        skipPostValidate: !!args["skip-post-validate"],
+        rawArgs: args
+      });
+      if (openFlag && result.pdfPath) {
+        log.info(`Opening ${result.pdfPath}`);
+        try {
+          await openPath(result.pdfPath);
+        } catch (error) {
+          const reason = error instanceof Error ? `: ${error.message}` : "";
+          log.warn(`Could not open the PDF automatically${reason}. Open it manually: ${result.pdfPath}`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof UsageError || error instanceof BuildError) {
+        log.error(error.message);
+        process.exit(error.exitCode);
+      }
+      throw error;
+    }
+  }
+});
+export {
+  resolvePort,
+  preview_default as default
+};

package/dist/preview-shell-rghtfmc8.js

@@ -0,0 +1,155 @@
+// Gutterpress preview shell controller (shared by the CLI preview and Electron).
+// Every source change takes one correctness-first path: paginate a fresh hidden
+// full document, then swap it in without flashing unpaginated content.
+//
+// TRANSPORT IS ABSTRACTED: change events arrive through connectChanges(), which
+  // uses WebSocket by default but honors window.__GUTTERPRESS_CHANGE_SOURCE so an Electron
+// host can feed the same full-reload signal over IPC.
+(function () {
+  'use strict';
+  var active = document.getElementById('gutterpress-active');
+  var building = null;
+  if (!active) return;
+
+  // Transparent bridge relay: forward host-toolbar commands to the active book
+  // iframe and relay its replies/events back to the host.
+  window.addEventListener('message', function (e) {
+    try {
+      if (window.parent !== window && e.source === window.parent) {
+        if (active && active.contentWindow) active.contentWindow.postMessage(e.data, '*');
+      } else if (active && e.source === active.contentWindow && window.parent !== window) {
+        window.parent.postMessage(e.data, '*');
+      }
+    } catch (_) {}
+  });
+
+  function fdoc(f) { try { return f.contentDocument; } catch (_) { return null; } }
+  function fwin(f) { try { return f.contentWindow; } catch (_) { return null; } }
+  function chapterOf(el) {
+    var chapter = el.closest && el.closest('[data-chapter-src]');
+    return chapter ? chapter.getAttribute('data-chapter-src') : null;
+  }
+  function blocksInChapter(d, chapter) {
+    var all = d.querySelectorAll('[data-source-line]');
+    if (!chapter) return all;
+    var matched = [];
+    for (var i = 0; i < all.length; i++) {
+      if (chapterOf(all[i]) === chapter) matched.push(all[i]);
+    }
+    return matched;
+  }
+
+  // data-source-line resets per source file, so preserve both chapter and line.
+  function capture(f) {
+    var d = fdoc(f); if (!d) return null;
+    var els = d.querySelectorAll('[data-source-line]'), best = null, bestTop = -Infinity;
+    for (var i = 0; i < els.length; i++) {
+      var r = els[i].getBoundingClientRect();
+      if (r.bottom < 0 || r.height === 0) continue;
+      if (r.top <= 80 && r.top > bestTop) { bestTop = r.top; best = els[i]; }
+    }
+    if (!best) {
+      for (var j = 0; j < els.length; j++) {
+        var rr = els[j].getBoundingClientRect();
+        if (rr.bottom > 0 && rr.height > 0) { best = els[j]; break; }
+      }
+    }
+    if (!best) return null;
+    return {
+      chapter: chapterOf(best),
+      line: best.getAttribute('data-source-line'),
+      offset: best.getBoundingClientRect().top
+    };
+  }
+
+  function restore(f, anchor) {
+    if (!anchor) return;
+    var w = fwin(f), d = fdoc(f); if (!w || !d) return;
+    var els = blocksInChapter(d, anchor.chapter);
+    var wanted = parseInt(anchor.line, 10), el = null, bestDiff = Infinity;
+    for (var i = 0; i < els.length; i++) {
+      var line = parseInt(els[i].getAttribute('data-source-line'), 10);
+      if (String(els[i].getAttribute('data-source-line')) === String(anchor.line)) {
+        el = els[i];
+        break;
+      }
+      var diff = Math.abs(line - wanted);
+      if (diff < bestDiff) { bestDiff = diff; el = els[i]; }
+    }
+    if (el) w.scrollBy(0, el.getBoundingClientRect().top - anchor.offset);
+  }
+
+  function onReady(f, callback) {
+    var w = fwin(f), d = fdoc(f); if (!w || !d) { callback(); return; }
+    var hasPaged = !!d.querySelector('script[src*="paged.polyfill"], script[src*="pagedjs"]');
+    if (hasPaged) {
+      var done = false;
+      var finish = function () { if (!done) { done = true; callback(); } };
+      w.addEventListener('renderingComplete', finish, { once: true });
+      setTimeout(finish, 180000);
+      return;
+    }
+    var attempts = 0;
+    (function poll() {
+      var current = fdoc(f);
+      if (current && current.querySelectorAll('.pagedjs_page').length > 0) { callback(); return; }
+      if (attempts++ < 800) setTimeout(poll, 25); else callback();
+    })();
+  }
+
+  function swap() {
+    // A newer reload invalidates any older hidden pagination. Its callback also
+    // checks identity before swapping, so stale work can never win a race.
+    if (building && building.parentNode) building.parentNode.removeChild(building);
+    building = null;
+
+    var frame = document.createElement('iframe');
+    frame.style.visibility = 'hidden';
+    frame.setAttribute('aria-hidden', 'true');
+    frame.src = '/book.html?gutterpressshell=1&bust=' + Date.now();
+    building = frame;
+
+    var finished = false;
+    function finish() {
+      if (finished || building !== frame) return;
+      finished = true;
+      // Capture at swap time, not rebuild start: the visible frame stays usable
+      // while a long book paginates and the user may scroll during that work.
+      var anchor = capture(active);
+      restore(frame, anchor);
+      frame.style.visibility = 'visible';
+      frame.removeAttribute('aria-hidden');
+      var old = active;
+      active = frame;
+      building = null;
+      requestAnimationFrame(function () {
+        requestAnimationFrame(function () {
+          if (old && old.parentNode) old.parentNode.removeChild(old);
+        });
+      });
+    }
+
+    frame.addEventListener('load', function () { onReady(frame, finish); });
+    document.body.appendChild(frame);
+  }
+
+  function connectChanges(onMessage) {
+    var source = window.__GUTTERPRESS_CHANGE_SOURCE;
+    if (source && typeof source.subscribe === 'function') return source.subscribe(onMessage);
+    var wsPath = window.__GUTTERPRESS_HMR || '/__gutterpress-hmr';
+    var ws = new WebSocket(location.origin.replace(/^http/, 'ws') + wsPath);
+    ws.onmessage = function (event) {
+      var message;
+      try { message = JSON.parse(event.data); } catch (_) { return; }
+      onMessage(message);
+    };
+    return function () { try { ws.close(); } catch (_) {} };
+  }
+
+  connectChanges(function (message) {
+    if (!message || !message.type) return;
+    // Accept legacy content-update producers, but never perform an isolated
+    // chapter splice: a changed boundary can affect every following page.
+    if (message.type === 'full-reload' || message.type === 'content-update') swap();
+  });
+})();

package/dist/project-source-0tg0r6vm.js

@@ -0,0 +1,17 @@
+import {
+  capabilitiesFor,
+  detectProjectSource,
+  findEnclosingRepoDir,
+  pickSyncRemote,
+  repoSubPath,
+  syncRemoteFor
+} from "./cli-1tyj4bk3.js";
+import"./cli-37x76zdn.js";
+export {
+  syncRemoteFor,
+  repoSubPath,
+  pickSyncRemote,
+  findEnclosingRepoDir,
+  detectProjectSource,
+  capabilitiesFor
+};

package/dist/publish-ztaet53r.js

@@ -0,0 +1,233 @@
+import {
+  connectPublishProvider,
+  listPublishAccounts,
+  listPublishProviders,
+  openPath,
+  publishConnectionStatus,
+  publishCredentialKey,
+  publishProviderFor,
+  runPublish
+} from "./cli-7ykx7pp0.js";
+import {
+  FileTokenStore,
+  log
+} from "./cli-h7phg3ka.js";
+import {
+  EXIT_CODES,
+  UsageError,
+  rejectExtraPositionals,
+  rejectUnknownFlags
+} from "./cli-hvqjs342.js";
+import"./cli-5bxx0c4y.js";
+import"./cli-1tyj4bk3.js";
+import"./cli-yja077f6.js";
+import"./cli-37x76zdn.js";
+
+// src/commands/publish.ts
+import { defineCommand } from "citty";
+import path from "node:path";
+async function readTokenFromStdin() {
+  if (process.stdin.isTTY)
+    return "";
+  let data = "";
+  for await (const chunk of process.stdin)
+    data += chunk;
+  return data.trim();
+}
+function emitResult(result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  for (const issue of result.issues) {
+    const line = `[${issue.id}] ${issue.message}`;
+    if (issue.severity === "error")
+      log.error(line);
+    else if (issue.severity === "warning")
+      log.warn(line);
+    else
+      log.info(line);
+  }
+  if (!result.ok) {
+    log.error(result.error ?? "Publish failed.");
+    return;
+  }
+  const outcome = result.outcome;
+  if (!outcome) {
+    log.success("Preflight passed — ready to publish.");
+    return;
+  }
+  if (outcome.kind === "published") {
+    log.success(outcome.detail ?? "Published.");
+    if (outcome.url)
+      log.info(`View it at: ${outcome.url}`);
+    for (const step of outcome.followUp ?? [])
+      log.info(`Next: ${step}`);
+  } else {
+    log.success(outcome.detail ?? "Upload package prepared.");
+    log.info(`Package folder: ${outcome.packageDir}`);
+    log.info(`Upload page:    ${outcome.openUrl}`);
+    outcome.checklist.forEach((step, i) => log.info(`  ${i + 1}. ${step}`));
+  }
+}
+var commandArgs = {
+  project: {
+    type: "positional",
+    description: "Project directory (default: cwd)",
+    required: false
+  },
+  provider: {
+    type: "string",
+    description: "Provider id: itch | drivethrurpg | kdp | azure-swa | shopify"
+  },
+  list: { type: "boolean", description: "List providers and connection status" },
+  connect: {
+    type: "boolean",
+    description: "Store an API key for --provider (from --token, the provider's env var, or piped stdin)"
+  },
+  disconnect: { type: "boolean", description: "Forget the stored key for --provider" },
+  account: {
+    type: "string",
+    description: "Named-credential label for --connect/--disconnect, so you can keep several accounts per provider (e.g. --account studio). Omit for the default account."
+  },
+  token: {
+    type: "string",
+    description: "API key for --connect (prefer piping via stdin or the provider env var to keep it out of shell history)"
+  },
+  file: {
+    type: "string",
+    description: "Artifact to publish (PDF path, or HTML export dir). Default: the manifest's output location"
+  },
+  manifest: { type: "string", description: "Path to manifest.yaml" },
+  "dry-run": { type: "boolean", description: "Preflight only; don't contact the platform" },
+  json: { type: "boolean", description: "Machine-readable JSON output (CI)" },
+  open: {
+    type: "boolean",
+    description: "Open the result page / guided upload page in the browser"
+  }
+};
+var publish_default = defineCommand({
+  meta: {
+    name: "publish",
+    description: "Publish the built PDF/HTML to a platform (itch.io, DriveThruRPG, Amazon KDP, Azure Static Web Apps, Shopify)"
+  },
+  args: commandArgs,
+  async run({ args, rawArgs }) {
+    try {
+      rejectUnknownFlags(rawArgs, commandArgs, "publish");
+      rejectExtraPositionals(args._, 1, "publish");
+    } catch (error) {
+      if (error instanceof UsageError) {
+        log.error(error.message);
+        process.exit(error.exitCode);
+      }
+      throw error;
+    }
+    const json = !!args.json;
+    const store = new FileTokenStore;
+    const deps = {
+      tokenStore: store,
+      onProgress: json ? undefined : (line) => log.info(line)
+    };
+    if (args.list) {
+      const providers = listPublishProviders();
+      const rows = await Promise.all(providers.map(async (p) => {
+        const status = await publishConnectionStatus(p, deps);
+        const accounts = p.credential.required ? await listPublishAccounts(p, deps) : [];
+        return {
+          id: p.id,
+          label: p.label,
+          kind: p.kind,
+          format: p.format,
+          connected: status.connected,
+          accounts
+        };
+      }));
+      if (json) {
+        console.log(JSON.stringify(rows, null, 2));
+      } else {
+        for (const r of rows) {
+          const status = r.kind === "guided" ? "no key needed" : r.connected ? "connected" : "not connected";
+          log.info(`${r.id.padEnd(13)} ${r.label.padEnd(22)} ${r.kind.padEnd(6)} ${r.format.padEnd(4)} ${status}`);
+          for (const acc of r.accounts) {
+            log.info(`    • ${acc.account ? acc.account : "(default)"}`);
+          }
+        }
+      }
+      return;
+    }
+    const providerId = typeof args.provider === "string" ? args.provider : "";
+    if (!providerId) {
+      log.error("Specify a provider: gutterpress publish --provider <itch|drivethrurpg|kdp|azure-swa|shopify> (or --list).");
+      process.exit(EXIT_CODES.USAGE);
+    }
+    let provider;
+    try {
+      provider = publishProviderFor(providerId);
+    } catch (e) {
+      log.error(e instanceof Error ? e.message : String(e));
+      process.exit(EXIT_CODES.USAGE);
+    }
+    const projectDir = path.resolve(args.project ?? ".");
+    const account = typeof args.account === "string" ? args.account.trim() : "";
+    if (args.disconnect) {
+      await store.delete(publishCredentialKey(provider.info.credential.host, account));
+      log.success(`Disconnected ${provider.info.label}${account ? ` (${account})` : ""}.`);
+      return;
+    }
+    if (args.connect) {
+      if (!provider.info.credential.required) {
+        log.info(`${provider.info.label} is a guided provider — no API key needed. Just run: gutterpress publish --provider ${provider.info.id}`);
+        return;
+      }
+      const envVar = provider.info.credential.envVar;
+      const token = typeof args.token === "string" && args.token.trim() || envVar && process.env[envVar]?.trim() || await readTokenFromStdin();
+      if (!token) {
+        log.error(`No API key given. Pass --token, set ${envVar ?? "the provider env var"}, or pipe the key via stdin.` + (provider.info.credential.tokenUrl ? `
+Create one at: ${provider.info.credential.tokenUrl}` : ""));
+        process.exit(EXIT_CODES.USAGE);
+      }
+      try {
+        await connectPublishProvider({
+          projectDir,
+          providerId: provider.info.id,
+          token,
+          ...account ? { account } : {},
+          manifestPath: typeof args.manifest === "string" ? args.manifest : undefined
+        }, deps);
+      } catch (e) {
+        log.error(e instanceof Error ? e.message : String(e));
+        process.exit(e instanceof UsageError ? e.exitCode : EXIT_CODES.FINDINGS);
+      }
+      log.success(`Connected ${provider.info.label}${account ? ` (${account})` : ""}. The key is stored in your user config, not the project.`);
+      return;
+    }
+    let result;
+    try {
+      result = await runPublish({
+        projectDir,
+        providerId: provider.info.id,
+        manifestPath: typeof args.manifest === "string" ? args.manifest : undefined,
+        artifactPath: typeof args.file === "string" ? args.file : undefined,
+        dryRun: !!args["dry-run"]
+      }, deps);
+    } catch (e) {
+      if (e instanceof UsageError) {
+        log.error(e.message);
+        process.exit(e.exitCode);
+      }
+      throw e;
+    }
+    emitResult(result, json);
+    if (result.ok && args.open && result.outcome) {
+      const target = result.outcome.kind === "guided" ? result.outcome.openUrl : result.outcome.url;
+      if (target)
+        await openPath(target).catch(() => {});
+    }
+    if (!result.ok)
+      process.exit(EXIT_CODES.FINDINGS);
+  }
+});
+export {
+  publish_default as default
+};

package/dist/render.d.ts

@@ -0,0 +1,20 @@
+/**
+ * gutterpress/render — the PURE, node-free render core.
+ *
+ * §1/§8 / ADR 0004: this entry deliberately exposes ONLY the browser-safe
+ * markdown→HTML→book.html pieces. It transitively imports markdown-it + its
+ * plugins, the inlined `markdown-it-paged.js`, and pure helpers — and NOTHING
+ * from `node:*`/`fs`/`path`/`url`. This is what the desktop's WebAdapter imports
+ * (a *value* import that stays PWA-clean), so the in-browser live preview (#33)
+ * can render the opened project entirely client-side with no localhost server
+ * and no puppeteer.
+ *
+ * The CLI build path keeps using `renderChapters` / `renderChaptersToFile` from
+ * `./lib/markdown/index.ts` (the node wrapper around this same core).
+ */
+export { assembleBookHtml } from "./lib/markdown/assemble";
+export type { AssembleBookHtmlOptions, ReadText, } from "./lib/markdown/assemble";
+export { createMarkdownRenderer, collectPluginCss, applyPlugins } from "./lib/markdown/renderer";
+export type { LoadedPlugin, GutterpressPlugin, GutterpressPluginMetadata, GutterpressPluginExport, } from "./lib/markdown/renderer";
+export { PAGED_CSS } from "./lib/markdown/markdown-it-paged.js";
+export { PAGEDJS_VERSION, PAGEDJS_POLYFILL_MARKER, pagedjsPolyfillTag, pagedjsPolyfillTagRegex, } from "./lib/pagedjs-marker";