perttool 0.1.0-alpha.2

package/dist/conversion/mermaid-import.js

@@ -0,0 +1,655 @@
+import { createHash } from "node:crypto";
+import { checkDocument } from "../application/check.js";
+import { compareStableStrings, normalizeMaxDiagnostics } from "../model/diagnostics.js";
+import { serializeTags, serializeTextField } from "../mutation/source.js";
+import { exportMermaid, } from "./mermaid.js";
+class ImportFailure extends Error {
+    code;
+    span;
+    constructor(code, message, span) {
+        super(message);
+        this.code = code;
+        this.span = span;
+        this.name = "ImportFailure";
+    }
+}
+const identifierPattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const digestPattern = /^sha256:[0-9a-f]{64}$/;
+const durationPattern = /^(?:0|[1-9][0-9]*)(?:\.[0-9]*[1-9])?[dhp]$/;
+const velocityPattern = /^(?:0|[1-9][0-9]*)(?:\.[0-9]*[1-9])?p\/(?:0|[1-9][0-9]*)(?:\.[0-9]*[1-9])?[dh]$/;
+const kinds = ["project", "resource", "milestone", "task", "gate"];
+function sha256(text) {
+    return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+}
+function sourceLines(text) {
+    const lines = [];
+    let start = 0;
+    let line = 0;
+    while (start < text.length) {
+        const newline = text.indexOf("\n", start);
+        const end = newline === -1 ? text.length : newline;
+        lines.push({ text: text.slice(start, end), start, line });
+        if (newline === -1)
+            break;
+        start = newline + 1;
+        line += 1;
+    }
+    return lines;
+}
+function lineSpan(line) {
+    return {
+        start: { offset: line.start, line: line.line, column: 0 },
+        end: { offset: line.start + line.text.length, line: line.line, column: line.text.length },
+    };
+}
+function diagnostic(failure) {
+    return {
+        code: failure.code,
+        severity: "error",
+        message: failure.message,
+        ...(failure.span === undefined ? {} : { span: failure.span }),
+        helpTopic: "mermaid",
+    };
+}
+function emptyResult(profile, failure, maxDiagnostics) {
+    const checked = checkDocument("", { maxDiagnostics });
+    return {
+        ok: false,
+        document: checked.document,
+        documentId: null,
+        diagnostics: [diagnostic(failure)],
+        diagnosticsTruncated: false,
+        profile,
+        analysis: "none",
+        capacityOverrides: new Map(),
+        artifact: null,
+        artifactDigest: null,
+        lossReport: { lossless: false, records: [] },
+        generatedIds: [],
+    };
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCanonicalObject(json, code, span) {
+    let value;
+    try {
+        value = JSON.parse(json);
+    }
+    catch {
+        throw new ImportFailure(code, "Mermaid profile JSONが不正です", span);
+    }
+    if (!isObject(value) || JSON.stringify(value) !== json) {
+        throw new ImportFailure(code, "Mermaid profile JSONがcanonical objectではありません", span);
+    }
+    return value;
+}
+function assertKeys(value, expected, span) {
+    if (Object.keys(value).length !== expected.length ||
+        Object.keys(value).some((key, index) => key !== expected[index])) {
+        throw new ImportFailure("PTCNV-102", "Mermaid profile recordのkeyまたはkey順が不正です", span);
+    }
+}
+function requiredString(value, key, span) {
+    const result = value[key];
+    if (typeof result !== "string") {
+        throw new ImportFailure("PTCNV-102", `${key}はstringでなければなりません`, span);
+    }
+    return result;
+}
+function nullableString(value, key, span) {
+    const result = value[key];
+    if (result !== null && typeof result !== "string") {
+        throw new ImportFailure("PTCNV-102", `${key}はstringまたはnullでなければなりません`, span);
+    }
+    return result;
+}
+function safeInteger(value, key, span) {
+    const result = value[key];
+    if (!Number.isSafeInteger(result)) {
+        throw new ImportFailure("PTCNV-102", `${key}はsafe integerでなければなりません`, span);
+    }
+    return result;
+}
+function stringArray(value, key, span) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new ImportFailure("PTCNV-102", `${key}はstring arrayでなければなりません`, span);
+    }
+    return value;
+}
+function parseHeader(value, span) {
+    assertKeys(value, [
+        "schema_version",
+        "profile",
+        "source_fidelity",
+        "record_count",
+        "metadata_digest",
+        "projection_digest",
+        "projection",
+    ], span);
+    if (value["schema_version"] !== "Perttool.MermaidProfile.v1") {
+        throw new ImportFailure("PTCNV-101", "Mermaid profile schema/versionが未対応です", span);
+    }
+    if (value["profile"] !== "perttool" || value["source_fidelity"] !== "semantic-v1") {
+        throw new ImportFailure("PTCNV-102", "Mermaid profile headerが不正です", span);
+    }
+    const recordCount = safeInteger(value, "record_count", span);
+    if (recordCount < 1) {
+        throw new ImportFailure("PTCNV-102", "record_countは1以上でなければなりません", span);
+    }
+    const metadataDigest = requiredString(value, "metadata_digest", span);
+    const projectionDigest = requiredString(value, "projection_digest", span);
+    if (!digestPattern.test(metadataDigest) || !digestPattern.test(projectionDigest)) {
+        throw new ImportFailure("PTCNV-102", "profile digestの形式が不正です", span);
+    }
+    const projection = value["projection"];
+    if (!isObject(projection)) {
+        throw new ImportFailure("PTCNV-102", "projection snapshotがobjectではありません", span);
+    }
+    assertKeys(projection, ["schema_version", "direction", "analysis", "capacity_overrides"], span);
+    if (projection["schema_version"] !== "Perttool.MermaidProjection.v1" ||
+        projection["direction"] !== "LR") {
+        throw new ImportFailure("PTCNV-101", "Mermaid projection schema/versionが未対応です", span);
+    }
+    const analysis = projection["analysis"];
+    if (!new Set(["none", "precedence", "resource", "both"]).has(analysis)) {
+        throw new ImportFailure("PTCNV-102", "projection analysisが不正です", span);
+    }
+    const rawOverrides = projection["capacity_overrides"];
+    if (!Array.isArray(rawOverrides)) {
+        throw new ImportFailure("PTCNV-102", "capacity_overridesがarrayではありません", span);
+    }
+    const overrides = new Map();
+    let previous = "";
+    for (const raw of rawOverrides) {
+        if (!isObject(raw)) {
+            throw new ImportFailure("PTCNV-102", "capacity overrideがobjectではありません", span);
+        }
+        assertKeys(raw, ["resource_id", "capacity"], span);
+        const resourceId = requiredString(raw, "resource_id", span);
+        const capacity = safeInteger(raw, "capacity", span);
+        if (!identifierPattern.test(resourceId) || capacity < 1 || compareStableStrings(previous, resourceId) >= 0) {
+            throw new ImportFailure("PTCNV-102", "capacity overrideのID、capacity、順序が不正です", span);
+        }
+        previous = resourceId;
+        overrides.set(resourceId, capacity);
+    }
+    if (overrides.size > 0 && analysis !== "resource" && analysis !== "both") {
+        throw new ImportFailure("PTCNV-102", "capacity overrideにはresource analysisが必要です", span);
+    }
+    return {
+        recordCount,
+        metadataDigest,
+        projectionDigest,
+        analysis: analysis,
+        capacityOverrides: overrides,
+    };
+}
+function validateRecordShape(record) {
+    const { kind, value } = record;
+    const span = lineSpan(record.line);
+    const keys = {
+        project: ["id", "version", "title", "description", "as_of", "duration_unit", "velocity", "finish", "critical_epsilon", "target_duration"],
+        resource: ["id", "title", "description", "capacity", "tags"],
+        milestone: ["id", "title", "description", "state", "tags"],
+        task: ["id", "from", "to", "title", "description", "estimate", "status", "priority", "requires", "owner", "tags", "blocked_reason", "source"],
+        gate: ["id", "from", "to", "reason"],
+    };
+    assertKeys(value, keys[kind], span);
+    for (const key of kind === "project"
+        ? ["id", "title", "finish", "critical_epsilon"]
+        : kind === "resource" || kind === "milestone"
+            ? ["id", "title"]
+            : kind === "task"
+                ? ["id", "from", "to", "title", "status"]
+                : ["id", "from", "to", "reason"]) {
+        requiredString(value, key, span);
+    }
+    if (kind === "project") {
+        if (safeInteger(value, "version", span) !== 1) {
+            throw new ImportFailure("PTCNV-101", "project versionが未対応です", span);
+        }
+        nullableString(value, "description", span);
+        nullableString(value, "as_of", span);
+        const unit = requiredString(value, "duration_unit", span);
+        if (!new Set(["day", "hour", "point"]).has(unit)) {
+            throw new ImportFailure("PTCNV-102", "duration_unitが不正です", span);
+        }
+        const velocity = nullableString(value, "velocity", span);
+        if (velocity !== null && !velocityPattern.test(velocity)) {
+            throw new ImportFailure("PTCNV-102", "velocity tokenがcanonicalではありません", span);
+        }
+        for (const key of ["critical_epsilon", "target_duration"]) {
+            const token = key === "target_duration"
+                ? nullableString(value, key, span)
+                : requiredString(value, key, span);
+            if (token !== null && !durationPattern.test(token)) {
+                throw new ImportFailure("PTCNV-102", `${key} tokenがcanonicalではありません`, span);
+            }
+        }
+    }
+    else if (kind === "resource") {
+        nullableString(value, "description", span);
+        if (safeInteger(value, "capacity", span) < 1) {
+            throw new ImportFailure("PTCNV-102", "resource capacityが不正です", span);
+        }
+        stringArray(value["tags"], "tags", span);
+    }
+    else if (kind === "milestone") {
+        nullableString(value, "description", span);
+        if (!new Set(["planned", "reached"]).has(value["state"])) {
+            throw new ImportFailure("PTCNV-102", "milestone stateが不正です", span);
+        }
+        stringArray(value["tags"], "tags", span);
+    }
+    else if (kind === "task") {
+        nullableString(value, "description", span);
+        nullableString(value, "owner", span);
+        nullableString(value, "blocked_reason", span);
+        nullableString(value, "source", span);
+        if (!new Set(["planned", "active", "blocked", "done"]).has(value["status"])) {
+            throw new ImportFailure("PTCNV-102", "task statusが不正です", span);
+        }
+        safeInteger(value, "priority", span);
+        stringArray(value["tags"], "tags", span);
+        const estimate = value["estimate"];
+        if (!isObject(estimate)) {
+            throw new ImportFailure("PTCNV-102", "task estimateがobjectではありません", span);
+        }
+        if (estimate["kind"] === "deterministic") {
+            assertKeys(estimate, ["kind", "duration"], span);
+            if (!durationPattern.test(requiredString(estimate, "duration", span))) {
+                throw new ImportFailure("PTCNV-102", "duration tokenがcanonicalではありません", span);
+            }
+        }
+        else if (estimate["kind"] === "pert") {
+            assertKeys(estimate, ["kind", "optimistic", "most_likely", "pessimistic"], span);
+            for (const key of ["optimistic", "most_likely", "pessimistic"]) {
+                if (!durationPattern.test(requiredString(estimate, key, span))) {
+                    throw new ImportFailure("PTCNV-102", "PERT tokenがcanonicalではありません", span);
+                }
+            }
+        }
+        else {
+            throw new ImportFailure("PTCNV-102", "task estimate kindが不正です", span);
+        }
+        const requirements = value["requires"];
+        if (!Array.isArray(requirements)) {
+            throw new ImportFailure("PTCNV-102", "requiresがarrayではありません", span);
+        }
+        let previous = "";
+        for (const raw of requirements) {
+            if (!isObject(raw)) {
+                throw new ImportFailure("PTCNV-102", "requirementがobjectではありません", span);
+            }
+            assertKeys(raw, ["resource_id", "units"], span);
+            const resourceId = requiredString(raw, "resource_id", span);
+            const units = safeInteger(raw, "units", span);
+            if (units < 1 || compareStableStrings(previous, resourceId) >= 0) {
+                throw new ImportFailure("PTCNV-102", "requirementの値または順序が不正です", span);
+            }
+            previous = resourceId;
+        }
+    }
+}
+function textField(name, value) {
+    return typeof value === "string" ? [serializeTextField(name, value, "\n")] : [];
+}
+function serializeProfileRecords(records) {
+    const declarations = [];
+    for (const { kind, value } of records) {
+        if (kind === "project") {
+            declarations.push([
+                `project ${value["id"]}:`,
+                `  version ${value["version"]}`,
+                `  title ${JSON.stringify(value["title"])}`,
+                ...textField("description", value["description"]),
+                ...(value["as_of"] === null ? [] : [`  as_of ${value["as_of"]}`]),
+                `  duration_unit ${value["duration_unit"]}`,
+                ...(value["velocity"] === null ? [] : [`  velocity ${value["velocity"]}`]),
+                `  finish ${value["finish"]}`,
+                `  critical_epsilon ${value["critical_epsilon"]}`,
+                ...(value["target_duration"] === null ? [] : [`  target_duration ${value["target_duration"]}`]),
+            ].join("\n"));
+        }
+        else if (kind === "resource") {
+            const tags = value["tags"];
+            declarations.push([
+                `resource ${value["id"]}:`,
+                `  title ${JSON.stringify(value["title"])}`,
+                ...textField("description", value["description"]),
+                `  capacity ${value["capacity"]}`,
+                ...(tags.length === 0 ? [] : [`  tags ${serializeTags(tags)}`]),
+            ].join("\n"));
+        }
+        else if (kind === "milestone") {
+            const tags = value["tags"];
+            declarations.push([
+                `milestone ${value["id"]}:`,
+                `  title ${JSON.stringify(value["title"])}`,
+                ...textField("description", value["description"]),
+                `  state ${value["state"]}`,
+                ...(tags.length === 0 ? [] : [`  tags ${serializeTags(tags)}`]),
+            ].join("\n"));
+        }
+        else if (kind === "task") {
+            const estimate = value["estimate"];
+            const requirements = value["requires"];
+            const tags = value["tags"];
+            declarations.push([
+                `task ${value["id"]} ${value["from"]} -> ${value["to"]}:`,
+                `  title ${JSON.stringify(value["title"])}`,
+                ...textField("description", value["description"]),
+                ...(estimate["kind"] === "deterministic"
+                    ? [`  duration ${estimate["duration"]}`]
+                    : [
+                        "  estimate:",
+                        `    optimistic ${estimate["optimistic"]}`,
+                        `    most_likely ${estimate["most_likely"]}`,
+                        `    pessimistic ${estimate["pessimistic"]}`,
+                    ]),
+                `  status ${value["status"]}`,
+                `  priority ${value["priority"]}`,
+                ...(requirements.length === 0
+                    ? []
+                    : [
+                        "  requires:",
+                        ...requirements.map((requirement) => `    ${requirement["resource_id"]} ${requirement["units"]}`),
+                    ]),
+                ...(value["owner"] === null ? [] : [`  owner ${JSON.stringify(value["owner"])}`]),
+                ...(tags.length === 0 ? [] : [`  tags ${serializeTags(tags)}`]),
+                ...textField("blocked_reason", value["blocked_reason"]),
+                ...(value["source"] === null ? [] : [`  source ${JSON.stringify(value["source"])}`]),
+            ].join("\n"));
+        }
+        else {
+            declarations.push([
+                `gate ${value["id"]} ${value["from"]} -> ${value["to"]}:`,
+                ...textField("reason", value["reason"]),
+            ].join("\n"));
+        }
+    }
+    return `${declarations.join("\n\n")}\n`;
+}
+function validateRecordOrder(records, expectedCount) {
+    if (records.length !== expectedCount || records.length === 0 || records[0].kind !== "project") {
+        throw new ImportFailure("PTCNV-103", "semantic record countまたはproject recordが不正です");
+    }
+    let previousRank = -1;
+    let previousId = "";
+    let projects = 0;
+    for (const record of records) {
+        const rank = kinds.indexOf(record.kind);
+        const id = requiredString(record.value, "id", lineSpan(record.line));
+        if (rank < previousRank || (rank === previousRank && compareStableStrings(previousId, id) >= 0)) {
+            throw new ImportFailure("PTCNV-103", "semantic record kindまたはID順が不正です", lineSpan(record.line));
+        }
+        if (record.kind === "project")
+            projects += 1;
+        if (rank !== previousRank)
+            previousId = "";
+        previousRank = rank;
+        previousId = id;
+    }
+    if (projects !== 1) {
+        throw new ImportFailure("PTCNV-103", "project recordはexactly one必要です");
+    }
+}
+function profileDetected(lines) {
+    const nonempty = lines.filter(({ text }) => text !== "");
+    const first = nonempty[0]?.text.replace(/^\uFEFF/, "").replace(/\r$/, "");
+    const second = nonempty[1]?.text.replace(/\r$/, "").trimStart();
+    return first === "flowchart LR" && second?.startsWith("%% perttool:profile ") === true;
+}
+function importProfile(text, lines, maxDiagnostics) {
+    if (text.startsWith("\uFEFF") || text.includes("\r") || !text.endsWith("\n")) {
+        throw new ImportFailure("PTCNV-102", "profile artifactはBOMなし、LF、末尾newlineを必要とします");
+    }
+    if (lines[0]?.text !== "flowchart LR" || lines[1]?.text.startsWith("  %% perttool:profile ") !== true) {
+        throw new ImportFailure("PTCNV-102", "profile artifact構造が不正です");
+    }
+    const lastNonempty = lines.findLastIndex(({ text }) => text !== "");
+    if (lastNonempty === -1 || lines[lastNonempty].text !== "  %% perttool:projection-end") {
+        throw new ImportFailure("PTCNV-102", "projection-end markerがありません");
+    }
+    if (lines.slice(lastNonempty + 1).some(({ text: line }) => line !== "")) {
+        throw new ImportFailure("PTCNV-102", "projection-end後にstatementがあります");
+    }
+    const headerLine = lines[1];
+    const headerJson = headerLine.text.slice("  %% perttool:profile ".length);
+    const header = parseHeader(parseCanonicalObject(headerJson, "PTCNV-102", lineSpan(headerLine)), lineSpan(headerLine));
+    const beginIndexes = lines.flatMap((line, index) => line.text === "  %% perttool:projection-begin" ? [index] : []);
+    const endIndexes = lines.flatMap((line, index) => line.text === "  %% perttool:projection-end" ? [index] : []);
+    if (beginIndexes.length !== 1 || endIndexes.length !== 1 || beginIndexes[0] <= 1 || endIndexes[0] <= beginIndexes[0] + 1) {
+        throw new ImportFailure("PTCNV-102", "projection marker構造が不正です");
+    }
+    const begin = beginIndexes[0];
+    const end = endIndexes[0];
+    const records = [];
+    const recordPattern = /^  %% perttool:(project|resource|milestone|task|gate) (.*)$/;
+    for (const line of lines.slice(2, begin)) {
+        const match = recordPattern.exec(line.text);
+        if (match === null) {
+            throw new ImportFailure("PTCNV-102", "semantic record lineが不正です", lineSpan(line));
+        }
+        const json = match[2];
+        records.push({
+            kind: match[1],
+            value: parseCanonicalObject(json, "PTCNV-103", lineSpan(line)),
+            json,
+            line,
+        });
+    }
+    validateRecordOrder(records, header.recordCount);
+    for (const record of records)
+        validateRecordShape(record);
+    const metadataBody = records.map(({ kind, json }) => `${kind} ${json}\n`).join("");
+    if (sha256(metadataBody) !== header.metadataDigest) {
+        throw new ImportFailure("PTCNV-104", "metadata digestが一致しません");
+    }
+    const projectionBody = lines.slice(begin + 1, end).map(({ text: line }) => `${line}\n`).join("");
+    if (sha256(projectionBody) !== header.projectionDigest) {
+        throw new ImportFailure("PTCNV-105", "projection digestが一致しません");
+    }
+    const artifact = serializeProfileRecords(records);
+    const checked = checkDocument(artifact, { maxDiagnostics });
+    if (!checked.ok) {
+        throw new ImportFailure("PTCNV-106", "metadataから復元したDSLが意味検査に失敗しました");
+    }
+    const reproduced = exportMermaid(artifact, {
+        analysis: header.analysis,
+        capacityOverrides: header.capacityOverrides,
+        maxDiagnostics,
+    });
+    if (!reproduced.ok || reproduced.artifact !== text) {
+        throw new ImportFailure("PTCNV-105", "projectionがmetadataのnode/edgeまたは解析snapshotと一致しません");
+    }
+    return {
+        ok: true,
+        document: checked.document,
+        documentId: checked.documentId,
+        diagnostics: checked.diagnostics,
+        diagnosticsTruncated: checked.diagnosticsTruncated,
+        profile: "perttool",
+        analysis: header.analysis,
+        capacityOverrides: header.capacityOverrides,
+        artifact,
+        artifactDigest: sha256(artifact),
+        lossReport: { lossless: true, records: [] },
+        generatedIds: [],
+    };
+}
+function decodeLabel(value) {
+    return value.replace(/#([0-9]+);/g, (match, digits) => {
+        const codePoint = Number(digits);
+        return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff &&
+            !(codePoint >= 0xd800 && codePoint <= 0xdfff)
+            ? String.fromCodePoint(codePoint)
+            : match;
+    });
+}
+function labelTitle(label, fallback) {
+    const decoded = decodeLabel(label);
+    const colon = decoded.indexOf(": ");
+    const body = colon === -1 ? decoded : decoded.slice(colon + 2);
+    const annotation = body.indexOf(" / ");
+    const title = (annotation === -1 ? body : body.slice(0, annotation)).trim();
+    return title === "" ? fallback : title;
+}
+function loss(code, message, elementId, span) {
+    return { code, severity: "warning", message, elementId, span, lossy: true };
+}
+function importPlain(text, lines, maxDiagnostics) {
+    const first = lines.find(({ text: line }) => line.trim() !== "");
+    if (first?.text.trim() !== "flowchart LR") {
+        throw new ImportFailure("PTCNV-102", "plain Mermaid v1はflowchart LRを必要とします", first === undefined ? undefined : lineSpan(first));
+    }
+    const nodes = new Map();
+    const edges = [];
+    const unsupported = [];
+    const nodePattern = /^\s*([A-Za-z][A-Za-z0-9_-]*)\(\("(.*)"\)\)\s*;?$/;
+    const edgePattern = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s+(?:-->|-\.->)\|"(.*)"\|\s+([A-Za-z][A-Za-z0-9_-]*)\s*;?$/;
+    const stylePattern = /^\s*(?:classDef|class|linkStyle)\b/;
+    const unsafePattern = /^\s*(?:---|%%\{|click\b|link\b|callback\b|<)|<\/?[A-Za-z!][^>]*>/i;
+    let edgeIndex = 0;
+    for (const line of lines) {
+        const trimmed = line.text.trim();
+        if (trimmed === "" || line === first || stylePattern.test(line.text))
+            continue;
+        if (unsafePattern.test(line.text)) {
+            throw new ImportFailure("PTCNV-102", "実行可能directiveまたはraw HTMLはimportできません", lineSpan(line));
+        }
+        const nodeMatch = nodePattern.exec(line.text);
+        if (nodeMatch !== null) {
+            const rawId = nodeMatch[1];
+            if (!nodes.has(rawId)) {
+                nodes.set(rawId, { rawId, title: labelTitle(nodeMatch[2], rawId), line });
+            }
+            continue;
+        }
+        const edgeMatch = edgePattern.exec(line.text);
+        if (edgeMatch !== null) {
+            const from = edgeMatch[1];
+            const to = edgeMatch[3];
+            edges.push({ from, to, title: labelTitle(edgeMatch[2], `Imported task ${edgeIndex + 1}`), line, index: edgeIndex });
+            edgeIndex += 1;
+            continue;
+        }
+        unsupported.push(line);
+    }
+    for (const edge of edges) {
+        if (!nodes.has(edge.from))
+            nodes.set(edge.from, { rawId: edge.from, title: edge.from, line: edge.line });
+        if (!nodes.has(edge.to))
+            nodes.set(edge.to, { rawId: edge.to, title: edge.to, line: edge.line });
+    }
+    if (nodes.size === 0) {
+        throw new ImportFailure("PTCNV-102", "import可能なnodeがありません");
+    }
+    const sortedNodes = [...nodes.values()].sort((left, right) => compareStableStrings(left.rawId, right.rawId));
+    const generatedIds = [];
+    const milestoneIds = new Map();
+    sortedNodes.forEach((node, index) => {
+        const generatedId = `MILESTONE_${String(index + 1).padStart(3, "0")}`;
+        milestoneIds.set(node.rawId, generatedId);
+        generatedIds.push({ sourceElement: `node:${node.rawId}`, generatedId });
+    });
+    edges.forEach((edge, index) => {
+        generatedIds.push({ sourceElement: `edge:${edge.index + 1}`, generatedId: `TASK_${String(index + 1).padStart(3, "0")}` });
+    });
+    const indegree = new Map(sortedNodes.map(({ rawId }) => [rawId, 0]));
+    const outdegree = new Map(sortedNodes.map(({ rawId }) => [rawId, 0]));
+    for (const edge of edges) {
+        indegree.set(edge.to, indegree.get(edge.to) + 1);
+        outdegree.set(edge.from, outdegree.get(edge.from) + 1);
+    }
+    const roots = new Set(sortedNodes.filter(({ rawId }) => indegree.get(rawId) === 0).map(({ rawId }) => rawId));
+    const sinks = sortedNodes.filter(({ rawId }) => outdegree.get(rawId) === 0);
+    const syntheticFinish = sinks.length !== 1;
+    const finish = syntheticFinish ? "MERMAID_FINISH" : milestoneIds.get(sinks[0].rawId);
+    if (syntheticFinish)
+        generatedIds.push({ sourceElement: "synthetic:finish", generatedId: finish });
+    const declarations = [[
+            "project IMPORTED_MERMAID:",
+            "  version 1",
+            "  title \"Imported Mermaid\"",
+            "  duration_unit day",
+            `  finish ${finish}`,
+        ].join("\n")];
+    for (const node of sortedNodes) {
+        declarations.push([
+            `milestone ${milestoneIds.get(node.rawId)}:`,
+            `  title ${JSON.stringify(node.title)}`,
+            ...(roots.has(node.rawId) ? ["  state reached"] : []),
+        ].join("\n"));
+    }
+    if (syntheticFinish) {
+        declarations.push(["milestone MERMAID_FINISH:", "  title \"Imported finish\""].join("\n"));
+    }
+    edges.forEach((edge, index) => {
+        declarations.push([
+            `task TASK_${String(index + 1).padStart(3, "0")} ${milestoneIds.get(edge.from)} -> ${milestoneIds.get(edge.to)}:`,
+            `  title ${JSON.stringify(edge.title)}`,
+            "  duration 1d",
+        ].join("\n"));
+    });
+    if (syntheticFinish) {
+        sinks.forEach((sink, index) => {
+            const id = `FINISH_GATE_${String(index + 1).padStart(3, "0")}`;
+            generatedIds.push({ sourceElement: `synthetic:sink:${sink.rawId}`, generatedId: id });
+            declarations.push([
+                `gate ${id} ${milestoneIds.get(sink.rawId)} -> MERMAID_FINISH:`,
+                "  reason \"Generated finish connector\"",
+            ].join("\n"));
+        });
+    }
+    const artifact = `${declarations.join("\n\n")}\n`;
+    const checked = checkDocument(artifact, { maxDiagnostics });
+    if (!checked.ok) {
+        throw new ImportFailure("PTCNV-106", "plain MermaidからvalidなAoA DAGを構成できません");
+    }
+    const records = [
+        loss("PTCNV-202", "project fieldをplain Mermaid既定値で生成しました", "IMPORTED_MERMAID", lineSpan(first)),
+        loss("PTCNV-204", "resource、estimate以外のtask fieldをplain Mermaidから復元できません", null, null),
+        ...sortedNodes.map((node) => loss("PTCNV-201", `${node.rawId}へstable milestone IDを生成しました`, milestoneIds.get(node.rawId), lineSpan(node.line))),
+        ...edges.flatMap((edge, index) => [
+            loss("PTCNV-201", `edge ${edge.index + 1}へstable task IDを生成しました`, `TASK_${String(index + 1).padStart(3, "0")}`, lineSpan(edge.line)),
+            loss("PTCNV-203", "plain Mermaid edgeのtask/gate kindを確定できないためtaskとして生成しました", `TASK_${String(index + 1).padStart(3, "0")}`, lineSpan(edge.line)),
+        ]),
+        ...(syntheticFinish
+            ? [loss("PTCNV-201", "複数sinkを統合するfinishとgate IDを生成しました", "MERMAID_FINISH", null)]
+            : []),
+        ...unsupported.map((line) => loss("PTCNV-205", "未対応Mermaid statementを無視しました", null, lineSpan(line))),
+    ];
+    return {
+        ok: true,
+        document: checked.document,
+        documentId: checked.documentId,
+        diagnostics: checked.diagnostics,
+        diagnosticsTruncated: checked.diagnosticsTruncated,
+        profile: "plain",
+        analysis: "none",
+        capacityOverrides: new Map(),
+        artifact,
+        artifactDigest: sha256(artifact),
+        lossReport: { lossless: false, records },
+        generatedIds,
+    };
+}
+export function importMermaid(text, options = {}) {
+    const maxDiagnostics = normalizeMaxDiagnostics(options.maxDiagnostics);
+    const lines = sourceLines(text);
+    const profile = profileDetected(lines) ? "perttool" : "plain";
+    try {
+        return profile === "perttool"
+            ? importProfile(text, lines, maxDiagnostics)
+            : importPlain(text, lines, maxDiagnostics);
+    }
+    catch (error) {
+        if (error instanceof ImportFailure) {
+            return emptyResult(profile, error, maxDiagnostics);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=mermaid-import.js.map