stego-cli 0.4.0 → 0.4.2

package/dist/stego-cli/src/modules/comments/commands/comments-sync-anchors.js

@@ -0,0 +1,33 @@
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+import { writeJson, writeText } from "../../../app/output-renderer.js";
+import { executeCommentsOperation } from "../application/comment-operations.js";
+import { parseCommentsOutputFormat } from "../infra/comments-repo.js";
+export function registerCommentsSyncAnchorsCommand(registry) {
+    registry.register({
+        name: "comments sync-anchors <manuscript>",
+        description: "Sync comment anchors",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--input <path>", description: "JSON payload path or '-'" },
+            { flags: "--format <format>", description: "text|json" }
+        ],
+        action: (context) => {
+            const manuscriptArg = context.positionals[0];
+            if (!manuscriptArg) {
+                throw new CliError("INVALID_USAGE", "Manuscript path is required. Use: stego comments sync-anchors <manuscript> --input <path|->.");
+            }
+            const outputFormat = parseCommentsOutputFormat(context.options.format);
+            const result = executeCommentsOperation({
+                subcommand: "sync-anchors",
+                cwd: context.cwd,
+                manuscriptArg,
+                options: context.options
+            });
+            if (outputFormat === "json") {
+                writeJson(result.payload);
+                return;
+            }
+            writeText(result.textMessage);
+        }
+    });
+}

package/dist/stego-cli/src/modules/comments/domain/comment-policy.js

@@ -0,0 +1,14 @@
+export const COMMENT_ID_PATTERN = /^CMT-\d{4,}$/;
+export function normalizeCommentId(value) {
+    return value.trim().toUpperCase();
+}
+export function isValidCommentId(value) {
+    return COMMENT_ID_PATTERN.test(normalizeCommentId(value));
+}
+export function normalizeCommentStatus(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "open" || normalized === "resolved") {
+        return normalized;
+    }
+    return null;
+}

package/dist/stego-cli/src/modules/comments/index.js

@@ -0,0 +1,20 @@
+import { registerCommentsReadCommand } from "./commands/comments-read.js";
+import { registerCommentsAddCommand } from "./commands/comments-add.js";
+import { registerCommentsReplyCommand } from "./commands/comments-reply.js";
+import { registerCommentsSetStatusCommand } from "./commands/comments-set-status.js";
+import { registerCommentsDeleteCommand } from "./commands/comments-delete.js";
+import { registerCommentsClearResolvedCommand } from "./commands/comments-clear-resolved.js";
+import { registerCommentsSyncAnchorsCommand } from "./commands/comments-sync-anchors.js";
+export const commentsModule = {
+    registerCommands(registry) {
+        registerCommentsReadCommand(registry);
+        registerCommentsAddCommand(registry);
+        registerCommentsReplyCommand(registry);
+        registerCommentsSetStatusCommand(registry);
+        registerCommentsDeleteCommand(registry);
+        registerCommentsClearResolvedCommand(registry);
+        registerCommentsSyncAnchorsCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/comment-operations.js";

package/dist/stego-cli/src/modules/comments/infra/comments-repo.js

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CliError } from "../../../../../shared/src/contracts/cli/index.js";
+export function parseCommentsOutputFormat(rawValue) {
+    if (rawValue === undefined || rawValue === null || rawValue === "text") {
+        return "text";
+    }
+    if (rawValue === "json") {
+        return "json";
+    }
+    throw new CliError("INVALID_USAGE", "Invalid --format value. Use 'text' or 'json'.");
+}
+export function resolveManuscriptPath(cwd, manuscriptArg) {
+    return path.resolve(cwd, manuscriptArg);
+}
+export function readManuscript(absolutePath, originalArg) {
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (!stat.isFile()) {
+            throw new Error("Not a file");
+        }
+    }
+    catch {
+        throw new CliError("INVALID_USAGE", `Manuscript file not found: ${originalArg}`);
+    }
+    try {
+        return fs.readFileSync(absolutePath, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_USAGE", `Unable to read manuscript: ${message}`);
+    }
+}
+export function writeManuscript(absolutePath, raw) {
+    try {
+        fs.writeFileSync(absolutePath, raw, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("WRITE_FAILURE", `Failed to update manuscript: ${message}`);
+    }
+}
+export function readJsonPayload(inputPath, cwd) {
+    let rawJson = "";
+    try {
+        rawJson = inputPath === "-"
+            ? fs.readFileSync(0, "utf8")
+            : fs.readFileSync(path.resolve(cwd, inputPath), "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new CliError("INVALID_PAYLOAD", `Unable to read input payload: ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch {
+        throw new CliError("INVALID_PAYLOAD", "Input payload is not valid JSON.");
+    }
+    if (!isPlainObject(parsed)) {
+        throw new CliError("INVALID_PAYLOAD", "Input payload must be a JSON object.");
+    }
+    return parsed;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/stego-cli/src/modules/comments/types.js

@@ -0,0 +1 @@
+export {};

package/dist/stego-cli/src/modules/compile/application/compile-manuscript.js

@@ -0,0 +1,16 @@
+import { nowIsoString } from "../../../platform/clock.js";
+import { renderCompiledManuscript } from "../domain/compile-structure.js";
+import { writeCompiledOutput } from "../infra/dist-writer.js";
+export function compileManuscript(input) {
+    const markdown = renderCompiledManuscript({
+        generatedAt: nowIsoString(),
+        projectId: input.project.id,
+        title: input.project.meta.title || input.project.id,
+        subtitle: input.project.meta.subtitle,
+        author: input.project.meta.author,
+        chapters: input.chapters,
+        compileStructureLevels: input.compileStructureLevels
+    });
+    const outputPath = writeCompiledOutput(input.project.distDir, input.project.id, markdown);
+    return { outputPath };
+}

package/dist/stego-cli/src/modules/compile/commands/build.js

@@ -0,0 +1,51 @@
+import { writeText } from "../../../app/output-renderer.js";
+import { resolveProjectContext } from "../../project/index.js";
+import { inspectProject, formatIssues, issueHasErrors } from "../../quality/index.js";
+import { resolveWorkspaceContext } from "../../workspace/index.js";
+import { compileManuscript } from "../application/compile-manuscript.js";
+export function registerBuildCommand(registry) {
+    registry.register({
+        name: "build",
+        description: "Compile manuscript output",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--project <project-id>", description: "Project id" },
+            { flags: "--root <path>", description: "Workspace root path" }
+        ],
+        action: (context) => {
+            const project = resolveProjectContext({
+                workspace: resolveWorkspaceContext({
+                    cwd: context.cwd,
+                    rootOption: readStringOption(context.options, "root")
+                }),
+                cwd: context.cwd,
+                env: context.env,
+                explicitProjectId: readStringOption(context.options, "project")
+            });
+            const report = inspectProject(project);
+            for (const line of formatIssues(report.issues)) {
+                writeText(line);
+            }
+            if (issueHasErrors(report.issues)) {
+                process.exitCode = 1;
+                return;
+            }
+            const result = compileManuscript({
+                project,
+                chapters: report.chapters,
+                compileStructureLevels: report.compileStructureLevels
+            });
+            writeText(`Build output: ${result.outputPath}`);
+        }
+    });
+}
+function readStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    return undefined;
+}

package/dist/stego-cli/src/modules/compile/domain/compile-structure.js

@@ -0,0 +1,105 @@
+export function renderCompiledManuscript(input) {
+    const tocEntries = [];
+    const previousGroupValues = new Map();
+    const previousGroupTitles = new Map();
+    const entryHeadingLevel = Math.min(6, 2 + input.compileStructureLevels.length);
+    const lines = [];
+    lines.push(`<!-- generated: ${input.generatedAt} -->`);
+    lines.push("");
+    lines.push(`# ${input.title}`);
+    lines.push("");
+    if (input.subtitle) {
+        lines.push(`_${input.subtitle}_`);
+        lines.push("");
+    }
+    if (input.author) {
+        lines.push(`Author: ${input.author}`);
+        lines.push("");
+    }
+    lines.push(`Generated: ${input.generatedAt}`);
+    lines.push("");
+    lines.push("## Table of Contents");
+    lines.push("");
+    if (input.compileStructureLevels.length === 0) {
+        lines.push(`- [Manuscript](#${slugify("Manuscript")})`);
+    }
+    lines.push("");
+    for (let chapterIndex = 0; chapterIndex < input.chapters.length; chapterIndex += 1) {
+        const chapter = input.chapters[chapterIndex];
+        let insertedBreakForEntry = false;
+        const levelChanged = [];
+        for (let levelIndex = 0; levelIndex < input.compileStructureLevels.length; levelIndex += 1) {
+            const level = input.compileStructureLevels[levelIndex];
+            const explicitValue = chapter.groupValues[level.key];
+            const previousValue = previousGroupValues.get(level.key);
+            const currentValue = explicitValue ?? previousValue;
+            const explicitTitle = level.titleKey ? toScalarMetadataString(chapter.metadata[level.titleKey]) : undefined;
+            const previousTitle = previousGroupTitles.get(level.key);
+            const currentTitle = explicitTitle ?? previousTitle;
+            const parentChanged = levelIndex > 0 && levelChanged[levelIndex - 1] === true;
+            const changed = parentChanged || currentValue !== previousValue;
+            levelChanged.push(changed);
+            if (!changed || !currentValue) {
+                previousGroupValues.set(level.key, currentValue);
+                previousGroupTitles.set(level.key, currentTitle);
+                continue;
+            }
+            if (level.pageBreak === "between-groups" && chapterIndex > 0 && !insertedBreakForEntry) {
+                lines.push("\\newpage");
+                lines.push("");
+                insertedBreakForEntry = true;
+            }
+            if (level.injectHeading) {
+                const heading = formatCompileStructureHeading(level, currentValue, currentTitle);
+                tocEntries.push({ level: levelIndex, heading });
+                const headingLevel = Math.min(6, 2 + levelIndex);
+                lines.push(`${"#".repeat(headingLevel)} ${heading}`);
+                lines.push("");
+            }
+            previousGroupValues.set(level.key, currentValue);
+            previousGroupTitles.set(level.key, currentTitle);
+        }
+        lines.push(`${"#".repeat(entryHeadingLevel)} ${chapter.title}`);
+        lines.push("");
+        lines.push(`<!-- source: ${chapter.relativePath} | order: ${chapter.order} | status: ${chapter.status} -->`);
+        lines.push("");
+        lines.push(chapter.body.trim());
+        lines.push("");
+    }
+    if (tocEntries.length > 0) {
+        const tocStart = lines.indexOf("## Table of Contents");
+        if (tocStart >= 0) {
+            const insertAt = tocStart + 2;
+            const tocLines = tocEntries.map((entry) => `${"  ".repeat(entry.level)}- [${entry.heading}](#${slugify(entry.heading)})`);
+            lines.splice(insertAt, 0, ...tocLines);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function formatCompileStructureHeading(level, value, title) {
+    const resolvedTitle = title || "";
+    if (!resolvedTitle && level.headingTemplate === "{label} {value}: {title}") {
+        return `${level.label} ${value}`;
+    }
+    return level.headingTemplate
+        .replaceAll("{label}", level.label)
+        .replaceAll("{value}", value)
+        .replaceAll("{title}", resolvedTitle)
+        .replace(/\s+/g, " ")
+        .replace(/:\s*$/, "")
+        .trim();
+}
+function toScalarMetadataString(rawValue) {
+    if (rawValue == null || rawValue === "" || Array.isArray(rawValue)) {
+        return undefined;
+    }
+    const normalized = String(rawValue).trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-");
+}

package/dist/stego-cli/src/modules/compile/index.js

@@ -0,0 +1,8 @@
+import { registerBuildCommand } from "./commands/build.js";
+export const compileModule = {
+    registerCommands(registry) {
+        registerBuildCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/compile-manuscript.js";

package/dist/stego-cli/src/modules/compile/infra/dist-writer.js

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import path from "node:path";
+export function writeCompiledOutput(distDir, projectId, markdown) {
+    fs.mkdirSync(distDir, { recursive: true });
+    const outputPath = path.join(distDir, `${projectId}.md`);
+    fs.writeFileSync(outputPath, markdown, "utf8");
+    return outputPath;
+}

package/dist/stego-cli/src/modules/compile/types.js

@@ -0,0 +1 @@
+export {};

package/dist/stego-cli/src/modules/export/application/run-export.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { parseExportFormat } from "../domain/exporter.js";
+import { markdownExporter } from "../infra/markdown-exporter.js";
+import { createPandocExporter } from "../infra/pandoc-exporter.js";
+const exporters = {
+    md: markdownExporter,
+    docx: createPandocExporter("docx"),
+    pdf: createPandocExporter("pdf"),
+    epub: createPandocExporter("epub")
+};
+export function runExport(input) {
+    const format = parseExportFormat(input.format.toLowerCase());
+    const exporter = exporters[format];
+    const targetPath = input.explicitOutputPath
+        || path.join(input.project.distDir, "exports", `${input.project.id}.${format}`);
+    const outputPath = path.resolve(input.project.workspace.repoRoot, targetPath);
+    const capability = exporter.canRun();
+    if (!capability.ok) {
+        throw new Error(capability.reason || `Exporter '${exporter.id}' cannot run.`);
+    }
+    exporter.run({
+        inputPath: input.inputPath,
+        outputPath
+    });
+    return {
+        outputPath,
+        format
+    };
+}

package/dist/stego-cli/src/modules/export/commands/export.js

@@ -0,0 +1,61 @@
+import { writeText } from "../../../app/output-renderer.js";
+import { compileManuscript } from "../../compile/index.js";
+import { resolveProjectContext } from "../../project/index.js";
+import { formatIssues, inspectProject, issueHasErrors } from "../../quality/index.js";
+import { resolveWorkspaceContext } from "../../workspace/index.js";
+import { runExport } from "../application/run-export.js";
+export function registerExportCommand(registry) {
+    registry.register({
+        name: "export",
+        description: "Export manuscript formats",
+        allowUnknownOptions: true,
+        options: [
+            { flags: "--project <project-id>", description: "Project id" },
+            { flags: "--format <format>", description: "md|docx|pdf|epub" },
+            { flags: "--output <path>", description: "Explicit output path" },
+            { flags: "--root <path>", description: "Workspace root path" }
+        ],
+        action: (context) => {
+            const project = resolveProjectContext({
+                workspace: resolveWorkspaceContext({
+                    cwd: context.cwd,
+                    rootOption: readStringOption(context.options, "root")
+                }),
+                cwd: context.cwd,
+                env: context.env,
+                explicitProjectId: readStringOption(context.options, "project")
+            });
+            const format = (readStringOption(context.options, "format") || "md").toLowerCase();
+            const report = inspectProject(project);
+            for (const line of formatIssues(report.issues)) {
+                writeText(line);
+            }
+            if (issueHasErrors(report.issues)) {
+                process.exitCode = 1;
+                return;
+            }
+            const compiled = compileManuscript({
+                project,
+                chapters: report.chapters,
+                compileStructureLevels: report.compileStructureLevels
+            });
+            const exported = runExport({
+                project,
+                format,
+                inputPath: compiled.outputPath,
+                explicitOutputPath: readStringOption(context.options, "output")
+            });
+            writeText(`Export output: ${exported.outputPath}`);
+        }
+    });
+}
+function readStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    return undefined;
+}

package/dist/stego-cli/src/modules/export/domain/exporter.js

@@ -0,0 +1,6 @@
+export function parseExportFormat(value) {
+    if (value === "md" || value === "docx" || value === "pdf" || value === "epub") {
+        return value;
+    }
+    throw new Error(`Unsupported export format '${value}'. Use md, docx, pdf, or epub.`);
+}

package/dist/stego-cli/src/modules/export/index.js

@@ -0,0 +1,8 @@
+import { registerExportCommand } from "./commands/export.js";
+export const exportModule = {
+    registerCommands(registry) {
+        registerExportCommand(registry);
+    }
+};
+export * from "./types.js";
+export * from "./application/run-export.js";

package/dist/stego-cli/src/modules/export/types.js

@@ -0,0 +1 @@
+export {};

package/dist/stego-cli/src/modules/index.js

@@ -0,0 +1,22 @@
+import { workspaceModule } from "./workspace/index.js";
+import { projectModule } from "./project/index.js";
+import { scaffoldModule } from "./scaffold/index.js";
+import { manuscriptModule } from "./manuscript/index.js";
+import { spineModule } from "./spine/index.js";
+import { metadataModule } from "./metadata/index.js";
+import { commentsModule } from "./comments/index.js";
+import { qualityModule } from "./quality/index.js";
+import { compileModule } from "./compile/index.js";
+import { exportModule } from "./export/index.js";
+export const coreModules = [
+    workspaceModule,
+    projectModule,
+    scaffoldModule,
+    manuscriptModule,
+    spineModule,
+    metadataModule,
+    commentsModule,
+    qualityModule,
+    compileModule,
+    exportModule
+];

package/dist/stego-cli/src/modules/manuscript/application/create-manuscript.js

@@ -0,0 +1,107 @@
+import path from "node:path";
+import { fileExists, ensureManuscriptDir, joinPath, listManuscriptOrderEntries, writeTextFile } from "../infra/manuscript-repo.js";
+import { inferNextManuscriptPrefix, parseManuscriptPrefix, parseOrderFromManuscriptFilename, parseRequestedManuscriptFilename } from "./order-inference.js";
+const DEFAULT_NEW_MANUSCRIPT_SLUG = "new-document";
+export function createNewManuscript(input) {
+    const project = input.project;
+    ensureManuscriptDir(project.manuscriptDir);
+    const requiredMetadataState = resolveRequiredMetadata(project);
+    if (requiredMetadataState.errors.length > 0) {
+        throw new Error(`Unable to resolve required metadata for project '${project.id}': ${requiredMetadataState.errors.join(" ")}`);
+    }
+    const existingEntries = listManuscriptOrderEntries(project.manuscriptDir);
+    const explicitPrefix = parseManuscriptPrefix(input.requestedPrefixRaw);
+    const requestedFilename = parseRequestedManuscriptFilename(input.requestedFilenameRaw);
+    if (requestedFilename && explicitPrefix != null) {
+        throw new Error("Options --filename and --i/-i cannot be used together.");
+    }
+    let filename;
+    if (requestedFilename) {
+        const requestedOrder = parseOrderFromManuscriptFilename(requestedFilename);
+        if (requestedOrder != null) {
+            const collision = existingEntries.find((entry) => entry.order === requestedOrder);
+            if (collision) {
+                throw new Error(`Manuscript prefix '${requestedOrder}' is already used by '${collision.filename}'. Choose a different filename prefix.`);
+            }
+        }
+        filename = requestedFilename;
+    }
+    else {
+        const nextPrefix = explicitPrefix ?? inferNextManuscriptPrefix(existingEntries);
+        const collision = existingEntries.find((entry) => entry.order === nextPrefix);
+        if (collision) {
+            throw new Error(`Manuscript prefix '${nextPrefix}' is already used by '${collision.filename}'. Re-run with --i <number> to choose an unused prefix.`);
+        }
+        filename = `${nextPrefix}-${DEFAULT_NEW_MANUSCRIPT_SLUG}.md`;
+    }
+    const manuscriptPath = joinPath(project.manuscriptDir, filename);
+    if (fileExists(manuscriptPath)) {
+        throw new Error(`Manuscript already exists: ${filename}`);
+    }
+    writeTextFile(manuscriptPath, renderNewManuscriptTemplate(requiredMetadataState.requiredMetadata));
+    return {
+        projectId: project.id,
+        filePath: path.relative(project.workspace.repoRoot, manuscriptPath)
+    };
+}
+export function parseManuscriptOutputFormat(raw) {
+    if (!raw || raw === "text") {
+        return "text";
+    }
+    if (raw === "json") {
+        return "json";
+    }
+    throw new Error("Invalid --format value. Use 'text' or 'json'.");
+}
+function resolveRequiredMetadata(project) {
+    const raw = project.meta.requiredMetadata;
+    if (raw == null) {
+        return {
+            requiredMetadata: project.workspace.config.requiredMetadata,
+            errors: []
+        };
+    }
+    if (!Array.isArray(raw)) {
+        return {
+            requiredMetadata: project.workspace.config.requiredMetadata,
+            errors: ["Project 'requiredMetadata' must be an array of metadata keys."]
+        };
+    }
+    const requiredMetadata = [];
+    const seen = new Set();
+    const errors = [];
+    for (const [index, entry] of raw.entries()) {
+        if (typeof entry !== "string") {
+            errors.push(`Project 'requiredMetadata' entry at index ${index} must be a string.`);
+            continue;
+        }
+        const key = entry.trim();
+        if (!key) {
+            errors.push(`Project 'requiredMetadata' entry at index ${index} cannot be empty.`);
+            continue;
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        requiredMetadata.push(key);
+    }
+    return {
+        requiredMetadata,
+        errors
+    };
+}
+function renderNewManuscriptTemplate(requiredMetadata) {
+    const lines = ["---", "status: draft"];
+    const seenKeys = new Set(["status"]);
+    for (const key of requiredMetadata) {
+        const normalized = key.trim();
+        if (!normalized || seenKeys.has(normalized)) {
+            continue;
+        }
+        seenKeys.add(normalized);
+        lines.push(`${normalized}:`);
+    }
+    lines.push("---", "");
+    return `${lines.join("\n")}\n`;
+}

package/dist/stego-cli/src/modules/manuscript/application/order-inference.js

@@ -0,0 +1,56 @@
+export function parseManuscriptPrefix(raw) {
+    if (raw == null) {
+        return undefined;
+    }
+    const normalized = raw.trim();
+    if (!normalized) {
+        throw new Error("Option --i/-i requires a numeric value.");
+    }
+    if (!/^\d+$/.test(normalized)) {
+        throw new Error(`Invalid manuscript prefix '${raw}'. Use a non-negative integer.`);
+    }
+    const parsed = Number(normalized);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new Error(`Invalid manuscript prefix '${raw}'. Use a smaller integer value.`);
+    }
+    return parsed;
+}
+export function parseRequestedManuscriptFilename(raw) {
+    if (raw == null) {
+        return undefined;
+    }
+    const normalized = raw.trim();
+    if (!normalized) {
+        throw new Error("Option --filename requires a value.");
+    }
+    if (/[\\/]/.test(normalized)) {
+        throw new Error(`Invalid filename '${raw}'. Use a filename only (no directory separators).`);
+    }
+    const withExtension = normalized.toLowerCase().endsWith(".md")
+        ? normalized
+        : `${normalized}.md`;
+    const stem = withExtension.slice(0, -3).trim();
+    if (!stem) {
+        throw new Error(`Invalid filename '${raw}'.`);
+    }
+    return withExtension;
+}
+export function parseOrderFromManuscriptFilename(filename) {
+    const match = filename.match(/^(\d+)[-_]/);
+    if (!match) {
+        return undefined;
+    }
+    return Number(match[1]);
+}
+export function inferNextManuscriptPrefix(entries) {
+    if (entries.length === 0) {
+        return 100;
+    }
+    if (entries.length === 1) {
+        return entries[0].order + 100;
+    }
+    const previous = entries[entries.length - 2].order;
+    const latest = entries[entries.length - 1].order;
+    const step = latest - previous;
+    return latest + (step > 0 ? step : 1);
+}