@open-press/cli 0.8.0 → 1.1.0

package/template/core/src/styles/openpress.css

@@ -1,14 +0,0 @@
-@import url("/openpress/fonts.css");
-@import url("/openpress/tokens.css");
-@import url("/openpress/content.css");
-@import url("/openpress/components.css");
-
-@import "./openpress/app-shell.css";
-@import "./openpress/workbench.css";
-@import "./openpress/workbench-panels.css";
-@import "./openpress/project-preview-panel.css";
-@import "./openpress/media-workspace.css";
-@import "./openpress/reader-runtime.css";
-@import "./openpress/public-viewer.css";
-@import "./openpress/responsive.css";
-@import "./openpress/print-route.css";

package/template/core/src/vite-env.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="vite/client" />
-
-// Workspace path constants injected by vite.config.ts at build time.
-// These come from openpress.config.mjs so the React app reflects the user's
-// configured documentDir / sourceDir / mediaDir / componentsDir.
-declare const __OPENPRESS_CONTENT_PATH__: string;
-declare const __OPENPRESS_MEDIA_PATH__: string;
-declare const __OPENPRESS_COMPONENTS_PATH__: string;
-declare const __OPENPRESS_PDF_HREF__: string;

package/template/core/tsconfig.json

@@ -1,40 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "lib": ["DOM", "DOM.Iterable", "ES2022"],
-    "allowJs": false,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "types": ["node", "vite/client"],
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "paths": {
-      "@open-press/core": ["./src/openpress/core/index.tsx"],
-      "@open-press/core/mdx": ["./src/openpress/mdx/index.ts"],
-      "@open-press/core/manuscript": ["./src/openpress/manuscript/index.tsx"],
-      "@open-press/core/numbering": ["./src/openpress/numbering/index.ts"],
-      "@/components": ["./document/components/index.ts", "./document/components/index.tsx"],
-      "@/components/*": ["./document/components/*"],
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": [
-    "src",
-    "document/**/*.ts",
-    "document/**/*.tsx",
-    "tests/**/*.test.ts",
-    "tests/**/*.test.tsx",
-    "tests/e2e/**/*.spec.ts",
-    "vite.config.ts",
-    "vitest.config.ts",
-    "playwright.reader.config.ts"
-  ]
-}

package/template/core/vite.config.ts

@@ -1,584 +0,0 @@
-import { fileURLToPath, URL } from "node:url";
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import type { IncomingMessage, ServerResponse } from "node:http";
-import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-import { loadConfig, publicPdfHref } from "./engine/runtime/config.mjs";
-import { searchSourceText } from "./engine/runtime/source-text-tools.mjs";
-import { handleCommentRequest } from "./engine/react/comment-endpoint.mjs";
-import { handleProjectAssetRequest } from "./engine/react/project-asset-endpoint.mjs";
-import { handleSourceEditRequest } from "./engine/react/source-edit-endpoint.mjs";
-
-const frameworkRoot = fileURLToPath(new URL("./", import.meta.url));
-const workspaceRoot = process.env.OPENPRESS_WORKSPACE_ROOT
-  ? path.resolve(process.env.OPENPRESS_WORKSPACE_ROOT)
-  : frameworkRoot;
-const sourceRoot = path.join(frameworkRoot, "src");
-const openpressCliPath = path.join(frameworkRoot, "engine", "cli.mjs");
-const staticServerPath = path.join(frameworkRoot, "engine", "output", "static-server.mjs");
-const openpressCoreEntry = path.join(frameworkRoot, "src", "openpress", "core", "index.tsx");
-const openpressMdxEntry = path.join(frameworkRoot, "src", "openpress", "mdx", "index.ts");
-const openpressManuscriptEntry = path.join(frameworkRoot, "src", "openpress", "manuscript", "index.tsx");
-const openpressNumberingEntry = path.join(frameworkRoot, "src", "openpress", "numbering", "index.ts");
-const openpressConfig = await loadConfig(workspaceRoot);
-const outputDir = openpressConfig.paths.outputDir;
-const reactDocumentRoot = openpressConfig.paths.documentRoot;
-const reactDocumentComponentsRoot = openpressConfig.paths.componentsDir;
-const reactDocumentEntry = path.join(reactDocumentRoot, "index.tsx");
-const activeContentDir = await fileExists(reactDocumentEntry)
-  ? path.join(reactDocumentRoot, "chapters")
-  : openpressConfig.paths.sourceDir;
-
-// Workspace directories — Vite resolves these at build time so that
-// `import.meta.glob("@workspace/content/**")` and friends follow the active
-// OpenPress authoring source instead of a hardcoded `document/` prefix.
-const workspaceAliases = {
-  "@workspace/content": activeContentDir,
-  "@workspace/media": openpressConfig.paths.mediaDir,
-  "@workspace/components": openpressConfig.paths.componentsDir,
-};
-
-// Relative paths displayed back to the user (e.g. "document/content/").
-// Resolved at build time so the React app does not hardcode `document/`.
-function relativeFromWorkspace(absolute: string) {
-  const rel = path.relative(workspaceRoot, absolute).replaceAll("\\", "/");
-  return rel.endsWith("/") ? rel : `${rel}`;
-}
-const workspaceDefines = {
-  __OPENPRESS_CONTENT_PATH__: JSON.stringify(relativeFromWorkspace(activeContentDir)),
-  __OPENPRESS_MEDIA_PATH__: JSON.stringify(relativeFromWorkspace(openpressConfig.paths.mediaDir)),
-  __OPENPRESS_COMPONENTS_PATH__: JSON.stringify(relativeFromWorkspace(openpressConfig.paths.componentsDir)),
-  __OPENPRESS_PDF_HREF__: JSON.stringify(publicPdfHref(openpressConfig)),
-};
-
-export default defineConfig({
-  base: "./",
-  cacheDir: path.join(workspaceRoot, ".openpress", "vite-client"),
-  plugins: [openpressLocalDeployPlugin(), react()],
-  define: workspaceDefines,
-  resolve: {
-    dedupe: ["react", "react-dom", "@mdx-js/react"],
-    alias: {
-      // Subpaths must come before the base path so resolution matches longest first.
-      "@open-press/core/mdx": openpressMdxEntry,
-      "@open-press/core/manuscript": openpressManuscriptEntry,
-      "@open-press/core/numbering": openpressNumberingEntry,
-      "@open-press/core": openpressCoreEntry,
-      "@/components": reactDocumentComponentsRoot,
-      "@": sourceRoot,
-      ...workspaceAliases,
-    },
-  },
-  optimizeDeps: {
-    include: [
-      "@mdx-js/react",
-      "lucide-react",
-      "react",
-      "react-dom",
-      "react-dom/client",
-      "react/jsx-dev-runtime",
-      "react/jsx-runtime",
-    ],
-  },
-  build: {
-    outDir: outputDir,
-    emptyOutDir: true,
-    rollupOptions: {
-      output: {
-        entryFileNames: "assets/[name]-[hash]-openpress.js",
-        chunkFileNames: "assets/[name]-[hash]-openpress.js",
-        assetFileNames: "assets/[name]-[hash]-openpress[extname]",
-      },
-    },
-  },
-  server: {
-    host: "127.0.0.1",
-    port: 5173,
-    fs: {
-      allow: Array.from(new Set([frameworkRoot, workspaceRoot])),
-    },
-    watch: {
-      ignored: ["**/.openpress/tmp/**", `**/${openpressConfig.outputDir}/**`],
-    },
-  },
-  preview: {
-    host: "127.0.0.1",
-    port: 5173,
-  },
-});
-
-function openpressLocalDeployPlugin() {
-  return {
-    name: "openpress-local-deploy-endpoint",
-    configureServer(server: { middlewares: { use: (path: string, handler: (req: IncomingMessage, res: ServerResponse) => void) => void } }) {
-      server.middlewares.use("/__openpress/local-pdf-export", (req, res) => {
-        void handleLocalPdfExportRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/local-pdf-file", (req, res) => {
-        void handleLocalPdfFileRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/status", (req, res) => {
-        void handleLocalStatusRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/search", (req, res) => {
-        void handleLocalSearchRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/source-edit", (req, res) => {
-        void handleSourceEditRequest(req, res, { root: workspaceRoot });
-      });
-      server.middlewares.use("/__openpress/deploy", (req, res) => {
-        void handleLocalDeployRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/comment", (req, res) => {
-        void handleCommentRequest(req, res, { root: workspaceRoot });
-      });
-      server.middlewares.use("/__openpress/media-upload", (req, res) => {
-        void handleLocalMediaUploadRequest(req, res);
-      });
-      server.middlewares.use("/__openpress/project-asset", (req, res) => {
-        void handleProjectAssetRequest(req, res, { root: workspaceRoot });
-      });
-      server.middlewares.use("/openpress/media", (req, res) => {
-        void handleLocalMediaFileRequest(req, res);
-      });
-    },
-  };
-}
-
-async function handleLocalMediaUploadRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "POST") {
-    writeJson(res, 405, { ok: false, message: "Media upload endpoint requires POST." });
-    return;
-  }
-
-  const rawFileName = headerValue(req.headers["x-openpress-file-name"]);
-  const decodedFileName = rawFileName ? safeDecodeURIComponent(rawFileName) : "";
-  const fileName = sanitizeMediaFileName(decodedFileName);
-  if (!fileName) {
-    writeJson(res, 400, { ok: false, message: "Media upload requires a valid file name." });
-    return;
-  }
-  if (!isAllowedMediaFile(fileName)) {
-    writeJson(res, 400, { ok: false, message: "Only png, jpg, jpeg, gif, svg, and webp files can be uploaded." });
-    return;
-  }
-
-  try {
-    const body = await readRequestBuffer(req, 30 * 1024 * 1024);
-    if (body.length === 0) {
-      writeJson(res, 400, { ok: false, message: "Uploaded media file is empty." });
-      return;
-    }
-    await fs.mkdir(openpressConfig.paths.mediaDir, { recursive: true });
-    const uniqueFileName = await uniqueMediaFileName(openpressConfig.paths.mediaDir, fileName);
-    const targetPath = path.join(openpressConfig.paths.mediaDir, uniqueFileName);
-    await fs.writeFile(targetPath, body);
-    const relativePath = relativeFromWorkspace(targetPath);
-    writeJson(res, 200, {
-      ok: true,
-      asset: {
-        fileName: uniqueFileName,
-        src: `/openpress/media/${encodeURIComponent(uniqueFileName)}`,
-        path: relativePath,
-        mention: `@media/${uniqueFileName}`,
-      },
-    });
-  } catch (error) {
-    writeJson(res, 500, { ok: false, message: error instanceof Error ? error.message : String(error) });
-  }
-}
-
-async function handleLocalMediaFileRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "GET" && req.method !== "HEAD") {
-    writeJson(res, 405, { ok: false, message: "Media file endpoint requires GET." });
-    return;
-  }
-
-  try {
-    const requestUrl = new URL(req.url ?? "/", "http://localhost");
-    const fileName = sanitizeMediaFileName(safeDecodeURIComponent(requestUrl.pathname.replace(/^\/openpress\/media\/?/, "").replace(/^\/+/, "")));
-    if (!fileName) {
-      writeJson(res, 404, { ok: false, message: "Media file not found." });
-      return;
-    }
-    const targetPath = path.join(openpressConfig.paths.mediaDir, fileName);
-    const resolvedTarget = path.resolve(targetPath);
-    const mediaRoot = path.resolve(openpressConfig.paths.mediaDir);
-    if (!resolvedTarget.startsWith(`${mediaRoot}${path.sep}`) && resolvedTarget !== mediaRoot) {
-      writeJson(res, 403, { ok: false, message: "Forbidden." });
-      return;
-    }
-    const body = await fs.readFile(resolvedTarget);
-    res.writeHead(200, {
-      "Content-Type": mediaMimeType(fileName),
-      "Cache-Control": "no-store",
-    });
-    if (req.method === "HEAD") {
-      res.end();
-    } else {
-      res.end(body);
-    }
-  } catch {
-    writeJson(res, 404, { ok: false, message: "Media file not found." });
-  }
-}
-
-async function handleLocalPdfExportRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "POST") {
-    writeJson(res, 405, { ok: false, message: "Local PDF export endpoint requires POST." });
-    return;
-  }
-
-  const result = await runLocalPdfExport();
-  const exists = await fileExists(openpressConfig.paths.pdf);
-  writeJson(res, result.code === 0 && exists ? 200 : 500, {
-    ok: result.code === 0 && exists,
-    code: result.code,
-    pdf: `/__openpress/local-pdf-file?ts=${Date.now()}`,
-    command: openpressCliCommand(["pdf", "."]),
-    stdout: result.stdout,
-    stderr: result.stderr,
-  });
-}
-
-async function handleLocalPdfFileRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "GET") {
-    writeJson(res, 405, { ok: false, message: "Local PDF file endpoint requires GET." });
-    return;
-  }
-
-  try {
-    const body = await fs.readFile(openpressConfig.paths.pdf);
-    res.writeHead(200, {
-      "Content-Type": "application/pdf",
-      "Content-Disposition": `inline; filename="${openpressConfig.pdf.filename}"`,
-      "Cache-Control": "no-store",
-    });
-    res.end(body);
-  } catch {
-    writeJson(res, 404, { ok: false, message: "Local PDF has not been generated yet." });
-  }
-}
-
-async function handleLocalStatusRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "GET") {
-    writeJson(res, 405, { ok: false, message: "Status endpoint requires GET." });
-    return;
-  }
-
-  const deployConfigured = isLocalDeployConfigured();
-  const deploymentInfo = deployConfigured
-    ? await readLocalDeploymentInfo()
-    : { deployed_at: undefined, pdf: publicPdfHref(openpressConfig), public_url: undefined };
-  const dirty = deployConfigured ? await isLocalDeploymentDirty(deploymentInfo.deployed_at) : false;
-  writeJson(res, 200, {
-    ok: true,
-    deployed_at: deploymentInfo.deployed_at,
-    pdf: deploymentInfo.pdf,
-    public_url: deploymentInfo.public_url,
-    dirty,
-    deploy_configured: deployConfigured,
-    deploy_adapter: openpressConfig.deploy.adapter,
-    deploy_source: openpressConfig.deploy.source,
-    deploy_project_name: openpressConfig.deploy.projectName,
-    deploy_setup_message: localDeploySetupMessage(),
-  });
-}
-
-async function handleLocalSearchRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "GET") {
-    writeJson(res, 405, { ok: false, message: "Search endpoint requires GET." });
-    return;
-  }
-
-  const requestUrl = new URL(req.url ?? "/", "http://localhost");
-  const query = (requestUrl.searchParams.get("q") ?? "").trim();
-  if (!query) {
-    writeJson(res, 400, { ok: false, message: "Search query is required." });
-    return;
-  }
-
-  try {
-    const report = await searchSourceText({
-      config: openpressConfig,
-      query,
-      scope: searchScopeFrom(requestUrl.searchParams),
-      caseSensitive: requestUrl.searchParams.get("caseSensitive") === "true",
-    });
-    writeJson(res, 200, { ok: true, ...report });
-  } catch (error) {
-    writeJson(res, 500, { ok: false, message: error instanceof Error ? error.message : String(error) });
-  }
-}
-
-async function handleLocalDeployRequest(req: IncomingMessage, res: ServerResponse) {
-  if (req.method !== "POST") {
-    writeJson(res, 405, { ok: false, message: "Deploy endpoint requires POST." });
-    return;
-  }
-
-  if (!isLocalDeployConfigured()) {
-    writeJson(res, 400, {
-      ok: false,
-      code: 2,
-      message: localDeploySetupMessage(),
-      deploy_configured: false,
-      deploy_adapter: openpressConfig.deploy.adapter,
-      deploy_source: openpressConfig.deploy.source,
-      deploy_project_name: openpressConfig.deploy.projectName,
-      command: openpressCliCommand(["deploy", ".", "--confirm"]),
-    });
-    return;
-  }
-
-  const result = await runLocalDeploy();
-  const deployedUrl = extractDeployUrl(result.stdout);
-  if (result.code === 0 && deployedUrl) {
-    await writeLocalDeploymentPublicUrl(deployedUrl);
-  }
-  const deploymentInfo = await readLocalDeploymentInfo();
-  const publicUrl = deployedUrl ?? deploymentInfo.public_url;
-  writeJson(res, result.code === 0 ? 200 : 500, {
-    ok: result.code === 0,
-    code: result.code,
-    deployed_at: deploymentInfo.deployed_at,
-    pdf: deployedUrl ? `${deployedUrl}/${openpressConfig.pdf.filename}` : deploymentInfo.pdf,
-    public_url: publicUrl,
-    dirty: false,
-    command: openpressCliCommand(["deploy", ".", "--confirm"]),
-    stdout: result.stdout,
-    stderr: result.stderr,
-  });
-}
-
-function runLocalPdfExport() {
-  return new Promise<{ code: number; stdout: string; stderr: string }>((resolve) => {
-    const child = spawn("node", [openpressCliPath, "pdf", "."], {
-      cwd: workspaceRoot,
-      shell: false,
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      resolve({ code: 1, stdout, stderr: `${stderr}${error.message}\n` });
-    });
-    child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-  });
-}
-
-function runLocalDeploy() {
-  return new Promise<{ code: number; stdout: string; stderr: string }>((resolve) => {
-    const child = spawn("node", [openpressCliPath, "deploy", ".", "--confirm"], {
-      cwd: workspaceRoot,
-      shell: false,
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      resolve({ code: 1, stdout, stderr: `${stderr}${error.message}\n` });
-    });
-    child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-  });
-}
-
-function isLocalDeployConfigured() {
-  if (openpressConfig.deploy.adapter === "cloudflare-pages") {
-    return typeof openpressConfig.deploy.projectName === "string" && openpressConfig.deploy.projectName.trim().length > 0;
-  }
-  return true;
-}
-
-function localDeploySetupMessage() {
-  if (isLocalDeployConfigured()) return undefined;
-  if (openpressConfig.deploy.adapter === "cloudflare-pages") {
-    return "Cloudflare Pages deployment requires `deploy.projectName` in openpress.config.mjs.";
-  }
-  return `Deployment adapter \`${openpressConfig.deploy.adapter}\` is not configured.`;
-}
-
-function searchScopeFrom(searchParams: URLSearchParams) {
-  return searchParams.get("scope") === "all" ? "all" : "content";
-}
-
-async function fileExists(filePath: string) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function readLocalDeploymentInfo() {
-  try {
-    const text = await fs.readFile(openpressConfig.paths.deployMetadata, "utf8");
-    const deployConfig = JSON.parse(text) as { deployed_at?: unknown; pdf?: unknown; public_url?: unknown };
-    return {
-      deployed_at: typeof deployConfig.deployed_at === "string" ? deployConfig.deployed_at : undefined,
-      pdf: typeof deployConfig.pdf === "string" ? deployConfig.pdf : publicPdfHref(openpressConfig),
-      public_url: typeof deployConfig.public_url === "string" ? deployConfig.public_url : undefined,
-    };
-  } catch {
-    return { deployed_at: undefined, pdf: publicPdfHref(openpressConfig), public_url: undefined };
-  }
-}
-
-async function writeLocalDeploymentPublicUrl(publicUrl: string) {
-  let deployConfig: Record<string, unknown> = {};
-  try {
-    deployConfig = JSON.parse(await fs.readFile(openpressConfig.paths.deployMetadata, "utf8")) as Record<string, unknown>;
-  } catch {
-    deployConfig = {};
-  }
-  await fs.mkdir(path.dirname(openpressConfig.paths.deployMetadata), { recursive: true });
-  await fs.writeFile(
-    openpressConfig.paths.deployMetadata,
-    `${JSON.stringify({ ...deployConfig, pdf: `${publicUrl}/${openpressConfig.pdf.filename}`, public_url: publicUrl }, null, 2)}\n`,
-    "utf8",
-  );
-}
-
-async function isLocalDeploymentDirty(deployedAt: string | undefined) {
-  if (!deployedAt) return false;
-  const deployedTime = new Date(deployedAt).getTime();
-  if (Number.isNaN(deployedTime)) return false;
-  const newestSourceMtime = await findNewestLocalSourceMtime(getLocalDeploymentSourcePaths());
-  return newestSourceMtime > deployedTime + 1000;
-}
-
-function getLocalDeploymentSourcePaths() {
-  return [
-    openpressConfig.paths.sourceDir,
-    openpressConfig.paths.mediaDir,
-    openpressConfig.paths.themeDir,
-    openpressConfig.paths.designDoc,
-    openpressConfig.paths.componentsDir,
-    path.join(frameworkRoot, "src"),
-    path.join(workspaceRoot, "index.html"),
-    path.join(workspaceRoot, "package.json"),
-    path.join(workspaceRoot, "openpress.config.mjs"),
-    openpressConfig.configPath,
-    path.join(workspaceRoot, "vite.config.ts"),
-  ];
-}
-
-function openpressCliCommand(args: string[]) {
-  const relativeCliPath = path.relative(workspaceRoot, openpressCliPath).replaceAll("\\", "/");
-  const displayCliPath = relativeCliPath && !relativeCliPath.startsWith("../") ? relativeCliPath : openpressCliPath;
-  return `node ${displayCliPath} ${args.join(" ")}`;
-}
-
-async function findNewestLocalSourceMtime(paths: string[]) {
-  const times = await Promise.all(paths.map((sourcePath) => findNewestLocalMtime(sourcePath)));
-  return Math.max(0, ...times);
-}
-
-async function findNewestLocalMtime(sourcePath: string): Promise<number> {
-  try {
-    const stat = await fs.stat(sourcePath);
-    if (!stat.isDirectory()) return stat.mtimeMs;
-    const entries = await fs.readdir(sourcePath, { withFileTypes: true });
-    const times = await Promise.all(entries.map((entry) => findNewestLocalMtime(path.join(sourcePath, entry.name))));
-    return Math.max(stat.mtimeMs, ...times);
-  } catch {
-    return 0;
-  }
-}
-
-function headerValue(value: string | string[] | undefined) {
-  return Array.isArray(value) ? value[0] : value;
-}
-
-function safeDecodeURIComponent(value: string) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-function sanitizeMediaFileName(value: string) {
-  const baseName = path.basename(value).trim();
-  if (!baseName) return "";
-  const ext = path.extname(baseName);
-  const stem = path.basename(baseName, ext)
-    .replace(/[\\/:*?"<>|#%{}^~[\]`]/g, "-")
-    .replace(/\s+/g, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-|-$/g, "");
-  if (!stem || !ext) return "";
-  return `${stem}${ext.toLowerCase()}`;
-}
-
-function isAllowedMediaFile(fileName: string) {
-  return /\.(png|jpe?g|gif|svg|webp)$/i.test(fileName);
-}
-
-function mediaMimeType(fileName: string) {
-  const ext = path.extname(fileName).toLowerCase();
-  if (ext === ".png") return "image/png";
-  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
-  if (ext === ".gif") return "image/gif";
-  if (ext === ".svg") return "image/svg+xml";
-  if (ext === ".webp") return "image/webp";
-  return "application/octet-stream";
-}
-
-async function uniqueMediaFileName(mediaDir: string, fileName: string) {
-  const ext = path.extname(fileName);
-  const stem = path.basename(fileName, ext);
-  let candidate = fileName;
-  let counter = 2;
-  while (await fileExists(path.join(mediaDir, candidate))) {
-    candidate = `${stem}-${counter}${ext}`;
-    counter += 1;
-  }
-  return candidate;
-}
-
-function readRequestBuffer(req: IncomingMessage, maxBytes: number) {
-  return new Promise<Buffer>((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    let total = 0;
-    req.on("data", (chunk: Buffer | string) => {
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      total += buffer.length;
-      if (total > maxBytes) {
-        reject(new Error("Uploaded media file is too large."));
-        req.destroy();
-        return;
-      }
-      chunks.push(buffer);
-    });
-    req.on("end", () => resolve(Buffer.concat(chunks)));
-    req.on("error", reject);
-  });
-}
-
-function writeJson(res: ServerResponse, status: number, body: unknown) {
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(`${JSON.stringify(body, null, 2)}\n`);
-}
-
-function extractDeployUrl(output: string) {
-  const match = output.match(/https:\/\/[^\s]+\.pages\.dev/);
-  return match?.[0]?.replace(/\/$/, "");
-}

package/template/packs/academic-paper/document/chapters/01-introduction/content/01-introduction.mdx

@@ -1,35 +0,0 @@
-## Introduction
-
-The purpose of this paper template is to provide a compact, readable structure for a
-machine-learning research manuscript written in a formal journal style.
-
-### Background and Motivation
-
-Recent studies have shown that modern experiments produce larger datasets and richer
-artifact pipelines, but the writing process is often bottlenecked by repeated formatting
-adjustments. A lightweight drafting layer can decouple scientific reasoning from
-typesetting concerns and let the author focus on experimental validity first.
-
-### Problem Statement
-
-The key challenge addressed in this draft is to keep the manuscript internally
-consistent while moving from scratch notes to a submission-ready narrative. The
-workflow should preserve section hierarchy, citation order, and figure/table integrity
-without requiring manual renumbering.
-
-### Contribution
-
-This demo paper includes the following contributions:
-
-- A reproducible chapter flow (`Introduction → Methods → Results and Discussion →
-  Conclusion`),
-- Consistent heading levels for major and minor sections,
-- Placeholder media and tables that can be swapped with real results,
-- A reference block and placeholder metadata for a clean handoff to final publication
-  tooling.
-
-### Paper Organization
-
-The paper is organized as follows: Section 2 details the methodology,
-Section 3 reports results and discusses representative scenarios,
-Section 4 summarizes conclusions and practical recommendations.