@oscharko-dev/keiko-quality-intelligence 0.2.0

package/dist/export/adapters/traceability.js

@@ -0,0 +1,142 @@
+// Requirement-to-test traceability export adapters (Epic #734, Issue #740).
+//
+// Pure-domain leaf. Renders the per-atom coverage matrix as an audit-ready, BIDIRECTIONAL
+// requirement<->test traceability matrix in CSV (spreadsheet-safe) and Markdown:
+//   * Requirements -> Tests: each requirement atom and the tests that cover it (+ status).
+//   * Tests -> Requirements: each test and the requirements it traces to.
+// Both directions are derived purely from the coverage matrix rows plus optional ALREADY-REDACTED
+// display fields — a requirement excerpt per row and a candidate-title lookup (#790) — never raw
+// atom text, so the adapter depends on nothing outside keiko-contracts/keiko-quality-intelligence
+// (ADR-0019 direction rule). Deterministic: rows are sorted by id, confidence is fixed-precision,
+// and there are no timestamps — so the export is byte-stable for identical inputs.
+import { inlineField } from "../textSafety.js";
+import { encodeSpreadsheetSafeRow, startsWithFormulaLead } from "./spreadsheetSafeCsv.js";
+/** CSV header row for the requirement -> tests direction. */
+export const TRACEABILITY_HEADERS = Object.freeze([
+    "Requirement ID",
+    "Requirement (redacted excerpt)",
+    "Status",
+    "Confidence",
+    "Covering Tests",
+    "Test Count",
+]);
+/** CSV header row for the test -> requirements (reverse) direction. */
+export const TRACEABILITY_REVERSE_HEADERS = Object.freeze([
+    "Test ID",
+    "Test Title",
+    "Requirements Covered",
+    "Requirement Count",
+]);
+/** Placeholder for an absent display value (legacy rows / unknown candidate). Em-dash, not a formula lead. */
+const ABSENT = "—";
+const byAtomIdAsc = (a, b) => (a.atomId < b.atomId ? -1 : a.atomId > b.atomId ? 1 : 0);
+const ascending = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+const fixed2 = (value) => value.toFixed(2);
+const joinSemicolon = (values) => values.join(" ; ");
+/**
+ * Invert the requirement->test rows into deterministic test->requirement rows. A test that covers
+ * several requirements appears once with all of them; ordering is fully sorted so the output is
+ * byte-stable.
+ */
+function invertToReverseRows(rows) {
+    const byCandidate = new Map();
+    for (const row of rows) {
+        for (const candidateId of row.coveringCandidateIds) {
+            const set = byCandidate.get(candidateId) ?? new Set();
+            set.add(row.atomId);
+            byCandidate.set(candidateId, set);
+        }
+    }
+    return [...byCandidate.entries()]
+        .map(([candidateId, set]) => ({
+        candidateId,
+        requirementIds: [...set].sort(ascending),
+    }))
+        .sort((a, b) => ascending(a.candidateId, b.candidateId));
+}
+// Escape Markdown table delimiters so an id containing a pipe cannot break the row structure, and
+// neutralise a spreadsheet formula lead (=,+,-,@) so a cell stays inert if the table is pasted into
+// a spreadsheet. inlineField runs FIRST so embedded newlines/tabs cannot split one logical row across
+// two physical Markdown lines (CWE-1284). Backslashes are escaped BEFORE pipes so a literal backslash
+// cannot consume the following escape and a pre-existing `\|` cannot smuggle an unescaped pipe (CWE-20).
+const mdCell = (value) => {
+    const oneLine = inlineField(value);
+    const safe = startsWithFormulaLead(oneLine) ? `'${oneLine}` : oneLine;
+    return safe.replace(/\\/gu, "\\\\").replace(/\|/gu, "\\|");
+};
+const mdRow = (cells) => `| ${cells.map(mdCell).join(" | ")} |`;
+/**
+ * Render the coverage matrix as a spreadsheet-safe, BIDIRECTIONAL CSV traceability matrix: a
+ * requirement->tests section followed by a blank line and a tests->requirements section. Each cell
+ * is formula-injection-safe via the shared encoder.
+ */
+export function adaptToTraceabilityCsv(rows, display = {}) {
+    const sorted = [...rows].sort(byAtomIdAsc);
+    let body = encodeSpreadsheetSafeRow(["Requirements to tests"]);
+    body += encodeSpreadsheetSafeRow(TRACEABILITY_HEADERS);
+    for (const row of sorted) {
+        body += encodeSpreadsheetSafeRow([
+            inlineField(row.atomId),
+            inlineField(row.requirementExcerptRedacted ?? ABSENT),
+            row.status,
+            fixed2(row.confidence),
+            inlineField(joinSemicolon(row.coveringCandidateIds)),
+            String(row.coveringCandidateIds.length),
+        ]);
+    }
+    body += "\r\n";
+    body += encodeSpreadsheetSafeRow(["Tests to requirements"]);
+    body += encodeSpreadsheetSafeRow(TRACEABILITY_REVERSE_HEADERS);
+    for (const reverse of invertToReverseRows(sorted)) {
+        body += encodeSpreadsheetSafeRow([
+            inlineField(reverse.candidateId),
+            inlineField(display.candidateTitleById?.get(reverse.candidateId) ?? ABSENT),
+            inlineField(joinSemicolon(reverse.requirementIds)),
+            String(reverse.requirementIds.length),
+        ]);
+    }
+    return body;
+}
+/**
+ * Render the coverage matrix as a BIDIRECTIONAL Markdown traceability document: a Requirements ->
+ * Tests table followed by a Tests -> Requirements table. Deterministic, pipe-escaped and
+ * formula-lead-neutralised.
+ */
+export function adaptToTraceabilityMarkdown(rows, display = {}) {
+    const sorted = [...rows].sort(byAtomIdAsc);
+    const lines = [
+        "# Requirement to test traceability matrix",
+        "",
+        "## Requirements → Tests",
+        "",
+        `| ${TRACEABILITY_HEADERS.join(" | ")} |`,
+        `| ${TRACEABILITY_HEADERS.map(() => "---").join(" | ")} |`,
+    ];
+    for (const row of sorted) {
+        const tests = row.coveringCandidateIds.length > 0 ? joinSemicolon(row.coveringCandidateIds) : ABSENT;
+        lines.push(mdRow([
+            row.atomId,
+            row.requirementExcerptRedacted ?? ABSENT,
+            row.status,
+            fixed2(row.confidence),
+            tests,
+            String(row.coveringCandidateIds.length),
+        ]));
+    }
+    lines.push("", "## Tests → Requirements", "");
+    lines.push(`| ${TRACEABILITY_REVERSE_HEADERS.join(" | ")} |`);
+    lines.push(`| ${TRACEABILITY_REVERSE_HEADERS.map(() => "---").join(" | ")} |`);
+    const reverseRows = invertToReverseRows(sorted);
+    if (reverseRows.length === 0) {
+        lines.push(mdRow([ABSENT, ABSENT, ABSENT, "0"]));
+    }
+    for (const reverse of reverseRows) {
+        lines.push(mdRow([
+            reverse.candidateId,
+            display.candidateTitleById?.get(reverse.candidateId) ?? ABSENT,
+            joinSemicolon(reverse.requirementIds),
+            String(reverse.requirementIds.length),
+        ]));
+    }
+    return lines.join("\n") + "\n";
+}

package/dist/export/adapters/xray.d.ts

@@ -0,0 +1,4 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+export declare const XRAY_CSV_HEADERS: readonly string[];
+export declare function adaptToXray(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): string;
+//# sourceMappingURL=xray.d.ts.map

package/dist/export/adapters/xray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xray.d.ts","sourceRoot":"","sources":["../../../src/export/adapters/xray.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAIvC,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAQ5C,CAAC;AASH,wBAAgB,WAAW,CACzB,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,MAAM,CA+CR"}

package/dist/export/adapters/xray.js

@@ -0,0 +1,72 @@
+// Xray CSV export adapter (Epic #270, Issue #283).
+//
+// Xray's "Test Case Importer" canonical shape: TCID, Summary, Description, Action,
+// Data, Result, Test Type. Like qTest, a multi-step test occupies multiple rows
+// where Summary/Description repeat across step rows.
+//
+// TMS-bound: invariant asserted first. Pure-domain — NO HTTP, NO Xray SDK.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { encodeSpreadsheetSafeRow } from "./spreadsheetSafeCsv.js";
+export const XRAY_CSV_HEADERS = Object.freeze([
+    "TCID",
+    "Summary",
+    "Description",
+    "Action",
+    "Data",
+    "Result",
+    "TestType",
+]);
+const buildDescription = (candidate) => {
+    if (candidate.preconditions.length === 0) {
+        return "";
+    }
+    return candidate.preconditions.join(" ; ");
+};
+export function adaptToXray(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        byId.set(candidate.id, candidate);
+    }
+    const sortedIds = bundle.contents
+        .map((entry) => entry.candidateId)
+        .slice()
+        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    let body = encodeSpreadsheetSafeRow(XRAY_CSV_HEADERS);
+    for (const id of sortedIds) {
+        const candidate = byId.get(id);
+        if (candidate === undefined) {
+            continue;
+        }
+        // `steps` and `expectedResults` are independent arrays with no co-length contract invariant, so
+        // the row count is the longer of the two — bounding the loop by `steps.length` alone would
+        // silently drop trailing expected results (and ALL of them when there are zero steps).
+        const rowCount = Math.max(candidate.steps.length, candidate.expectedResults.length);
+        if (rowCount === 0) {
+            body += encodeSpreadsheetSafeRow([
+                candidate.id,
+                candidate.title,
+                buildDescription(candidate),
+                "",
+                "",
+                "",
+                "Manual",
+            ]);
+            continue;
+        }
+        for (let i = 0; i < rowCount; i += 1) {
+            const action = candidate.steps[i] ?? "";
+            const result = candidate.expectedResults[i] ?? "";
+            body += encodeSpreadsheetSafeRow([
+                candidate.id,
+                candidate.title,
+                buildDescription(candidate),
+                action,
+                "",
+                result,
+                "Manual",
+            ]);
+        }
+    }
+    return body;
+}

package/dist/export/formats.d.ts

@@ -0,0 +1,29 @@
+import type { QualityIntelligenceExportAdapter } from "@oscharko-dev/keiko-contracts";
+/**
+ * Public type alias for the adapter discriminator. Identical in shape to the
+ * contract-side `QualityIntelligenceExportAdapter`. Spec-mandated name.
+ */
+export type QualityIntelligenceExportFormat = QualityIntelligenceExportAdapter;
+/**
+ * Frozen per-format adapter descriptor. The `adapterId` mirrors the contract
+ * adapter name; `bytesPerRowHint` is a deterministic capacity hint for callers
+ * that need to pre-size buffers. The hints are static guidance — the actual
+ * serialised output is what counts, not the hint.
+ */
+export interface QualityIntelligenceExportFormatDescriptor {
+    readonly format: QualityIntelligenceExportFormat;
+    readonly adapterId: QualityIntelligenceExportFormat;
+    readonly bytesPerRowHint: number;
+    readonly filenameExtension: string;
+}
+/**
+ * Frozen lookup table mapping format → adapter descriptor. Eleven formats,
+ * mirrors `QUALITY_INTELLIGENCE_EXPORT_ADAPTERS` exactly.
+ */
+export declare const QUALITY_INTELLIGENCE_EXPORT_FORMAT_TABLE: Readonly<Record<QualityIntelligenceExportFormat, QualityIntelligenceExportFormatDescriptor>>;
+/**
+ * Returns the descriptor for `format`. Pure lookup; the table is frozen at
+ * module load so the returned reference is stable for the process lifetime.
+ */
+export declare function getExportFormatDescriptor(format: QualityIntelligenceExportFormat): QualityIntelligenceExportFormatDescriptor;
+//# sourceMappingURL=formats.d.ts.map

package/dist/export/formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.d.ts","sourceRoot":"","sources":["../../src/export/formats.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,+BAA+B,CAAC;AAEtF;;;GAGG;AACH,MAAM,MAAM,+BAA+B,GAAG,gCAAgC,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,WAAW,yCAAyC;IACxD,QAAQ,CAAC,MAAM,EAAE,+BAA+B,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,+BAA+B,CAAC;IACpD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AASD;;;GAGG;AACH,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,MAAM,CAAC,+BAA+B,EAAE,yCAAyC,CAAC,CAalF,CAAC;AAEH;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,+BAA+B,GACtC,yCAAyC,CAE3C"}

package/dist/export/formats.js

@@ -0,0 +1,34 @@
+// Frozen format table for Quality Intelligence export adapters (Epic #270, Issue #283).
+//
+// Reuses the `QualityIntelligenceExportAdapter` discriminator from
+// `@oscharko-dev/keiko-contracts` so the adapter id is the single source of truth.
+// The local re-export under the name `QualityIntelligenceExportFormat` is the
+// type alias the public spec calls for; downstream callers may import either
+// name.
+//
+// Pure-domain leaf. NO IO. NO new runtime dependency.
+const descriptor = (format, bytesPerRowHint, filenameExtension) => Object.freeze({ format, adapterId: format, bytesPerRowHint, filenameExtension });
+/**
+ * Frozen lookup table mapping format → adapter descriptor. Eleven formats,
+ * mirrors `QUALITY_INTELLIGENCE_EXPORT_ADAPTERS` exactly.
+ */
+export const QUALITY_INTELLIGENCE_EXPORT_FORMAT_TABLE = Object.freeze({
+    "jira-issues": descriptor("jira-issues", 512, "csv"),
+    qtest: descriptor("qtest", 384, "csv"),
+    xray: descriptor("xray", 384, "csv"),
+    polarion: descriptor("polarion", 384, "csv"),
+    alm: descriptor("alm", 384, "csv"),
+    csv: descriptor("csv", 256, "csv"),
+    json: descriptor("json", 1024, "json"),
+    "spreadsheet-safe-csv": descriptor("spreadsheet-safe-csv", 256, "csv"),
+    markdown: descriptor("markdown", 512, "md"),
+    "plain-text": descriptor("plain-text", 384, "txt"),
+    "quality-center": descriptor("quality-center", 384, "txt"),
+});
+/**
+ * Returns the descriptor for `format`. Pure lookup; the table is frozen at
+ * module load so the returned reference is stable for the process lifetime.
+ */
+export function getExportFormatDescriptor(format) {
+    return QUALITY_INTELLIGENCE_EXPORT_FORMAT_TABLE[format];
+}

package/dist/export/index.d.ts

@@ -0,0 +1,4 @@
+export { QUALITY_INTELLIGENCE_EXPORT_FORMAT_TABLE, getExportFormatDescriptor, type QualityIntelligenceExportFormat, type QualityIntelligenceExportFormatDescriptor, } from "./formats.js";
+export { adaptToAlm, adaptToCsv, adaptToJiraIssues, adaptToJson, adaptToMarkdown, adaptToPlainText, adaptToPolarion, adaptToQtest, adaptToQualityCenter, adaptToSpreadsheetSafeCsv, adaptToXray, ALM_CSV_HEADERS, CSV_HEADERS, encodeSpreadsheetSafeCell, encodeSpreadsheetSafeRow, JIRA_CSV_HEADERS, POLARION_CSV_HEADERS, QTEST_CSV_HEADERS, SPREADSHEET_FORMULA_LEAD_CHARS, SPREADSHEET_SAFE_CSV_HEADERS, startsWithFormulaLead, XRAY_CSV_HEADERS, adaptToTraceabilityCsv, adaptToTraceabilityMarkdown, TRACEABILITY_HEADERS, TRACEABILITY_REVERSE_HEADERS, type QualityIntelligenceTraceabilityDisplayOptions, type QualityIntelligenceTraceabilityRow, } from "./adapters/index.js";
+export { serializeExportBundle, type SerializedExportBundle } from "./serialize.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/export/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/export/index.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,wCAAwC,EACxC,yBAAyB,EACzB,KAAK,+BAA+B,EACpC,KAAK,yCAAyC,GAC/C,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,yBAAyB,EACzB,WAAW,EACX,eAAe,EACf,WAAW,EACX,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,8BAA8B,EAC9B,4BAA4B,EAC5B,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,4BAA4B,EAC5B,KAAK,6CAA6C,EAClD,KAAK,kCAAkC,GACxC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,qBAAqB,EAAE,KAAK,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/export/index.js

@@ -0,0 +1,10 @@
+// Public barrel for the Quality Intelligence export sub-namespace (Epic #270, Issue #283).
+//
+// Pure-domain leaf. NO IO, NO HTTP, NO provider SDK imports, NO new runtime dependency.
+// Adapters consume `QualityIntelligenceExportBundle` + `QualityIntelligenceTestCaseCandidate`
+// from `@oscharko-dev/keiko-contracts` and produce typed serialised bodies. Persistence of
+// these bodies is owned by `@oscharko-dev/keiko-evidence` via the side-file primitive — this
+// layer never touches `node:fs`.
+export { QUALITY_INTELLIGENCE_EXPORT_FORMAT_TABLE, getExportFormatDescriptor, } from "./formats.js";
+export { adaptToAlm, adaptToCsv, adaptToJiraIssues, adaptToJson, adaptToMarkdown, adaptToPlainText, adaptToPolarion, adaptToQtest, adaptToQualityCenter, adaptToSpreadsheetSafeCsv, adaptToXray, ALM_CSV_HEADERS, CSV_HEADERS, encodeSpreadsheetSafeCell, encodeSpreadsheetSafeRow, JIRA_CSV_HEADERS, POLARION_CSV_HEADERS, QTEST_CSV_HEADERS, SPREADSHEET_FORMULA_LEAD_CHARS, SPREADSHEET_SAFE_CSV_HEADERS, startsWithFormulaLead, XRAY_CSV_HEADERS, adaptToTraceabilityCsv, adaptToTraceabilityMarkdown, TRACEABILITY_HEADERS, TRACEABILITY_REVERSE_HEADERS, } from "./adapters/index.js";
+export { serializeExportBundle } from "./serialize.js";

package/dist/export/serialize.d.ts

@@ -0,0 +1,17 @@
+import type { QualityIntelligenceExportBundle, QualityIntelligenceTestCaseCandidate } from "@oscharko-dev/keiko-contracts";
+import type { QualityIntelligenceExportFormat } from "./formats.js";
+export interface SerializedExportBundle {
+    readonly format: QualityIntelligenceExportFormat;
+    readonly body: string;
+    readonly byteLen: number;
+}
+/**
+ * Serialise an export bundle by dispatching on `bundle.targetAdapter`. The contract
+ * invariant is asserted up front (TMS-bound bundles MUST carry
+ * `redactionAttested === true`) before any adapter is invoked.
+ *
+ * `byteLen` is the UTF-8 byte length of the body — what an evidence side-file would
+ * persist, which is what callers downstream need for capacity accounting.
+ */
+export declare function serializeExportBundle(bundle: QualityIntelligenceExportBundle, candidates: readonly QualityIntelligenceTestCaseCandidate[]): SerializedExportBundle;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/export/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/export/serialize.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,+BAA+B,EAC/B,oCAAoC,EACrC,MAAM,+BAA+B,CAAC;AAevC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,+BAA+B,CAAC;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAqBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,+BAA+B,EACvC,UAAU,EAAE,SAAS,oCAAoC,EAAE,GAC1D,sBAAsB,CAexB"}

package/dist/export/serialize.js

@@ -0,0 +1,56 @@
+// Dispatcher for Quality Intelligence export-bundle serialisation (Epic #270, Issue #283).
+//
+// Pure-domain leaf. Pre-asserts the contract invariant on the bundle, then dispatches
+// to the format-specific adapter. The dispatch table is `satisfies` typed so every
+// `QualityIntelligenceExportFormat` MUST have a registered adapter — adding a new
+// format is a compile error here, by design.
+import { assertExportBundleInvariant } from "@oscharko-dev/keiko-contracts";
+import { adaptToAlm } from "./adapters/alm.js";
+import { adaptToCsv } from "./adapters/csv.js";
+import { adaptToJiraIssues } from "./adapters/jira.js";
+import { adaptToJson } from "./adapters/json.js";
+import { adaptToMarkdown } from "./adapters/markdown.js";
+import { adaptToPlainText } from "./adapters/plaintext.js";
+import { adaptToPolarion } from "./adapters/polarion.js";
+import { adaptToQtest } from "./adapters/qtest.js";
+import { adaptToQualityCenter } from "./adapters/qualityCenter.js";
+import { adaptToSpreadsheetSafeCsv } from "./adapters/spreadsheetSafeCsv.js";
+import { adaptToXray } from "./adapters/xray.js";
+import { getExportFormatDescriptor } from "./formats.js";
+const DISPATCH = Object.freeze({
+    "jira-issues": adaptToJiraIssues,
+    qtest: adaptToQtest,
+    xray: adaptToXray,
+    polarion: adaptToPolarion,
+    alm: adaptToAlm,
+    csv: adaptToCsv,
+    json: adaptToJson,
+    "spreadsheet-safe-csv": adaptToSpreadsheetSafeCsv,
+    markdown: adaptToMarkdown,
+    "plain-text": adaptToPlainText,
+    "quality-center": adaptToQualityCenter,
+});
+/**
+ * Serialise an export bundle by dispatching on `bundle.targetAdapter`. The contract
+ * invariant is asserted up front (TMS-bound bundles MUST carry
+ * `redactionAttested === true`) before any adapter is invoked.
+ *
+ * `byteLen` is the UTF-8 byte length of the body — what an evidence side-file would
+ * persist, which is what callers downstream need for capacity accounting.
+ */
+export function serializeExportBundle(bundle, candidates) {
+    assertExportBundleInvariant(bundle);
+    const format = bundle.targetAdapter;
+    // The dispatch table is total over the format union; the indirection makes a
+    // future format addition a compile-time failure here.
+    const adapter = DISPATCH[format];
+    // Pre-touch the descriptor so a missing format mapping shows up as a clear
+    // runtime error rather than `undefined` propagating. Pure lookup, no side effect.
+    getExportFormatDescriptor(format);
+    const body = adapter(bundle, candidates);
+    // TextEncoder is a Web-standard global (no node:* import); identical UTF-8 byte
+    // length to Buffer.byteLength but keeps this leaf free of node:* surface so the
+    // purity guard rule does not need to be widened for the export sub-namespace.
+    const byteLen = new TextEncoder().encode(body).length;
+    return { format, body, byteLen };
+}

package/dist/export/textSafety.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Collapse embedded line-breaking / tab whitespace in a single field value to one space. Leaves all
+ * other characters (including ordinary spaces and non-ASCII text) untouched.
+ *
+ * Scope note: this folds ONLY the line-breaking / tab run above — its sole job is to keep a field on
+ * one logical line so it cannot break the structure of a line-oriented serializer. It does NOT strip
+ * other C0/C1/DEL control characters (NUL, BEL, backspace, …) or bidi/zero-width code points; the
+ * line-oriented Markdown / plain-text serializers assume candidate text is already control-clean and
+ * redacted by the upstream persist-time redactor (#278/#284), which is the single content-safety
+ * chokepoint. This helper is a structural folder, not a content scrubber.
+ */
+export declare function inlineField(value: string): string;
+/** Apply {@link inlineField} across a list of field values. */
+export declare function inlineFields(values: readonly string[]): string[];
+//# sourceMappingURL=textSafety.d.ts.map

package/dist/export/textSafety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textSafety.d.ts","sourceRoot":"","sources":["../../src/export/textSafety.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAEhE"}

package/dist/export/textSafety.js

@@ -0,0 +1,30 @@
+// Inline-field sanitisation for Quality Intelligence export serializers (Epic #711).
+//
+// Candidate fields (title, steps, preconditions, expected results, tags) are free text. A value that
+// contains a line break or tab would break the structure of a line-oriented serializer — a newline
+// inside a Markdown list item silently terminates the list; a newline inside a plain-text or
+// key/value row splits one field across two lines. `inlineField` folds any run of line-breaking or
+// tab whitespace into a single space so each field renders as exactly one logical unit, without
+// otherwise altering the content. Pure, deterministic; NO IO, NO new runtime dependency.
+// Matching control whitespace (CR, LF, tab, vertical tab, form feed) and the Unicode line
+// separators is the entire purpose of this helper, so the control characters are intentional.
+// eslint-disable-next-line no-control-regex
+const LINE_BREAKING_RUN = /[\r\n\t\u000b\f\u0085\u2028\u2029]+/gu;
+/**
+ * Collapse embedded line-breaking / tab whitespace in a single field value to one space. Leaves all
+ * other characters (including ordinary spaces and non-ASCII text) untouched.
+ *
+ * Scope note: this folds ONLY the line-breaking / tab run above — its sole job is to keep a field on
+ * one logical line so it cannot break the structure of a line-oriented serializer. It does NOT strip
+ * other C0/C1/DEL control characters (NUL, BEL, backspace, …) or bidi/zero-width code points; the
+ * line-oriented Markdown / plain-text serializers assume candidate text is already control-clean and
+ * redacted by the upstream persist-time redactor (#278/#284), which is the single content-safety
+ * chokepoint. This helper is a structural folder, not a content scrubber.
+ */
+export function inlineField(value) {
+    return value.replace(LINE_BREAKING_RUN, " ");
+}
+/** Apply {@link inlineField} across a list of field values. */
+export function inlineFields(values) {
+    return values.map(inlineField);
+}

package/dist/generation/candidateBounds.d.ts

@@ -0,0 +1,10 @@
+export declare const GENERATED_CANDIDATE_RESPONSE_MAX_ITEMS = 1024;
+export declare const GENERATED_CANDIDATE_TITLE_MAX_CHARS = 256;
+export declare const GENERATED_CANDIDATE_TEXT_ITEM_MAX_CHARS = 1000;
+export declare const GENERATED_CANDIDATE_TAG_MAX_CHARS = 120;
+export declare const GENERATED_CANDIDATE_PRECONDITION_MAX_ITEMS = 20;
+export declare const GENERATED_CANDIDATE_STEP_MAX_ITEMS = 50;
+export declare const GENERATED_CANDIDATE_EXPECTED_RESULT_MAX_ITEMS = 50;
+export declare const GENERATED_CANDIDATE_TAG_MAX_ITEMS = 30;
+export declare const GENERATED_CANDIDATE_EVIDENCE_INDEX_MAX_ITEMS = 120;
+//# sourceMappingURL=candidateBounds.d.ts.map

package/dist/generation/candidateBounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidateBounds.d.ts","sourceRoot":"","sources":["../../src/generation/candidateBounds.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sCAAsC,OAAO,CAAC;AAC3D,eAAO,MAAM,mCAAmC,MAAM,CAAC;AACvD,eAAO,MAAM,uCAAuC,OAAO,CAAC;AAC5D,eAAO,MAAM,iCAAiC,MAAM,CAAC;AACrD,eAAO,MAAM,0CAA0C,KAAK,CAAC;AAC7D,eAAO,MAAM,kCAAkC,KAAK,CAAC;AACrD,eAAO,MAAM,6CAA6C,KAAK,CAAC;AAChE,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,4CAA4C,MAAM,CAAC"}

package/dist/generation/candidateBounds.js

@@ -0,0 +1,14 @@
+// Shared bounds for model-generated Quality Intelligence candidates.
+//
+// These limits keep generated test cases concise enough for persistence, judge prompts, exports, and
+// UI review while still allowing rich manual test steps. They intentionally mirror the stricter UI
+// projection/edit-route envelope instead of the wider raw-provider payload size.
+export const GENERATED_CANDIDATE_RESPONSE_MAX_ITEMS = 1024;
+export const GENERATED_CANDIDATE_TITLE_MAX_CHARS = 256;
+export const GENERATED_CANDIDATE_TEXT_ITEM_MAX_CHARS = 1000;
+export const GENERATED_CANDIDATE_TAG_MAX_CHARS = 120;
+export const GENERATED_CANDIDATE_PRECONDITION_MAX_ITEMS = 20;
+export const GENERATED_CANDIDATE_STEP_MAX_ITEMS = 50;
+export const GENERATED_CANDIDATE_EXPECTED_RESULT_MAX_ITEMS = 50;
+export const GENERATED_CANDIDATE_TAG_MAX_ITEMS = 30;
+export const GENERATED_CANDIDATE_EVIDENCE_INDEX_MAX_ITEMS = 120;

package/dist/generation/index.d.ts

@@ -0,0 +1,4 @@
+export { QI_TEST_DESIGN_SYSTEM_PROMPT, QI_TEST_DESIGN_RESPONSE_SCHEMA, buildTestDesignInstruction, type BuildTestDesignInstructionInput, } from "./prompt.js";
+export { parseGeneratedCandidates, type ParseGeneratedCandidatesInput, type ParseGeneratedCandidatesResult, } from "./parseGeneratedCandidates.js";
+export { splitRequirementsIntoAtoms, type IngestedRequirementAtom, type SplitRequirementsOptions, } from "./requirementsIngestion.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/generation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generation/index.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,KAAK,+BAA+B,GACrC,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,GACpC,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,0BAA0B,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,4BAA4B,CAAC"}

package/dist/generation/index.js

@@ -0,0 +1,20 @@
+// Public barrel for the Quality Intelligence model-routed generation sub-namespace
+// (Epic #270, Issue #272/#278/#279). Pure-domain prompt assembly, requirements-text ingestion,
+// and model-output parsing. No IO, no model call; the server tier supplies the gateway port.
+//
+// DETERMINISM-FIRST INVARIANT (Epic #761, Issue #763):
+// - The structural stages — coverage mapping, deduplication, validation, and candidate-ID
+//   derivation — are 100% deterministic and replayable: `parseGeneratedCandidates` derives every
+//   candidate id from a content hash (sha256 of ordinal + title + cited atoms), so identical model
+//   text over identical evidence yields identical ids regardless of run id, model, seed, or sampling
+//   temperature.
+// - The model is invoked ONLY to draft candidate text; its output is an attributed delta. The
+//   evidence manifest records which model produced it (`modelId`), the request parameters used
+//   (`modelParameters`, e.g. responseFormat), and the seed (`seedUsed`, null when unsupported).
+// - Where the model supports seeding, the same inputs + seed reproduce the same sampling; where it
+//   does not, the content-hashed ids still make the run replayable for coverage/dedup/validate.
+// - No model configured → the deterministic baseline still holds (judge accepts all, refinement
+//   skipped); only the drafting step is unavailable.
+export { QI_TEST_DESIGN_SYSTEM_PROMPT, QI_TEST_DESIGN_RESPONSE_SCHEMA, buildTestDesignInstruction, } from "./prompt.js";
+export { parseGeneratedCandidates, } from "./parseGeneratedCandidates.js";
+export { splitRequirementsIntoAtoms, } from "./requirementsIngestion.js";

package/dist/generation/parseGeneratedCandidates.d.ts

@@ -0,0 +1,27 @@
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import type { PolicyProfile } from "../domain/policyProfile.js";
+type Candidate = QualityIntelligence.QualityIntelligenceTestCaseCandidate;
+type RunId = QualityIntelligence.QualityIntelligenceRunId;
+type AtomId = QualityIntelligence.QualityIntelligenceEvidenceAtomId;
+export interface ParseGeneratedCandidatesInput {
+    readonly runId: RunId;
+    /** Atom IDs in the SAME order they were numbered (1-based) in the prompt evidence block. */
+    readonly atomIds: readonly AtomId[];
+    readonly profile?: PolicyProfile;
+    readonly maxCandidates: number;
+}
+export interface ParseGeneratedCandidatesResult {
+    readonly candidates: readonly Candidate[];
+    /** True when no JSON object/array could be recovered from the model text at all. */
+    readonly recovered: boolean;
+    /** Count of raw items skipped because they lacked a usable title or steps. */
+    readonly skipped: number;
+}
+/**
+ * Parse raw model output into validated candidates. Returns `recovered: false` when no JSON value
+ * could be located, so the orchestrator can fail the run with a clear, non-secret reason instead
+ * of silently emitting zero candidates.
+ */
+export declare const parseGeneratedCandidates: (rawText: string, input: ParseGeneratedCandidatesInput) => ParseGeneratedCandidatesResult;
+export {};
+//# sourceMappingURL=parseGeneratedCandidates.d.ts.map

package/dist/generation/parseGeneratedCandidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGeneratedCandidates.d.ts","sourceRoot":"","sources":["../../src/generation/parseGeneratedCandidates.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAYhE,KAAK,SAAS,GAAG,mBAAmB,CAAC,oCAAoC,CAAC;AAC1E,KAAK,KAAK,GAAG,mBAAmB,CAAC,wBAAwB,CAAC;AAC1D,KAAK,MAAM,GAAG,mBAAmB,CAAC,iCAAiC,CAAC;AAWpE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,4FAA4F;IAC5F,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,oFAAoF;IACpF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AA2QD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,OAAO,6BAA6B,KACnC,8BAqBF,CAAC"}