@oscharko-dev/keiko-server 0.2.0

package/dist/qualityIntelligence/handoffRoutes.js

@@ -0,0 +1,341 @@
+// Quality Intelligence Conversation Center → workflow handoff route (Epic #270, Issue #281).
+//
+// Single additive HTTP handler:
+//   * POST /api/quality-intelligence/handoff
+//
+// Hard constraints:
+//   * The Conversation Center is the existing chat surface — QI integration is via WORKFLOW
+//     HANDOFF only, never a parallel chat/agent/memory channel.
+//   * The request body IS a `QualityIntelligenceConversationCenterHandoff` envelope. The envelope
+//     carries ONLY refs (chat-message id, run id, source-envelope ids) — never chat content,
+//     never an excerpt, never a body. Unknown top-level keys are REJECTED so a misbehaving
+//     client cannot smuggle content through the seam.
+//   * The route resolves `requestedByChatMessageId` against the existing chat-store seam
+//     (`UiStore`). If recognised, the handoff is persisted as a single system message on the
+//     owning chat (taskType=`qi-handoff`); the message content is a fixed, non-echoing
+//     descriptor — the envelope itself stays out of the message body.
+//   * If the chat-message ref is unknown → `404 QI_HANDOFF_UNKNOWN_CHAT_MESSAGE`.
+//   * No provider SDK imports. No new runtime dependency. A "design-tests" handoff additionally
+//     starts a model-routed QI run in the BACKGROUND from the chat's connected folder (through the
+//     Keiko Model Gateway + Harness, like any QI run) and links the run id back to the chat — this
+//     is the governed workflow handoff (Issue #281), not a parallel chat/agent/model channel.
+//   * Test Intelligence reference (TI) is acknowledged only by plain phrase; this file MUST
+//     NOT contain any reference to the prior external TI-namespace packages — enforced by
+//     `independenceGuard.test.ts` and the repo-wide `npm run check:qi-supply-chain` gate.
+//
+// Group export `QI_HANDOFF_ROUTE_GROUP` keeps the route registration mechanically merge-safe
+// with sibling QI epic work (e.g. #280) — the dispatcher in `routes.ts` only needs to spread
+// the group.
+import { randomUUID } from "node:crypto";
+import { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import { qiHandoffErrorBody, } from "./handoffErrors.js";
+import { containsForbiddenSecretShape } from "./connectorErrors.js";
+import { executeQiRun } from "./runExecution.js";
+import { qiRunRegistry } from "./runRegistry.js";
+// ─── Body reading ──────────────────────────────────────────────────────────────
+const MAX_BODY_BYTES = 64 * 1024;
+class BodyTooLargeError extends Error {
+    constructor() {
+        super("Handoff body exceeds the route cap");
+        this.name = "BodyTooLargeError";
+    }
+}
+const readBody = (req) => new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let capped = false;
+    req.on("data", (chunk) => {
+        total += chunk.length;
+        if (total > MAX_BODY_BYTES) {
+            if (!capped) {
+                capped = true;
+                chunks.length = 0;
+                reject(new BodyTooLargeError());
+                req.resume();
+            }
+            return;
+        }
+        chunks.push(chunk);
+    });
+    req.on("end", () => {
+        if (!capped)
+            resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    req.on("error", reject);
+});
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+// ─── Envelope validation (envelope-only invariant) ─────────────────────────────
+// The envelope's permitted top-level keys. Anything else MUST be rejected so a leaky
+// client cannot smuggle chat content, bodies, excerpts, or unstructured payloads
+// through this seam.
+const ALLOWED_ENVELOPE_KEYS = new Set([
+    "id",
+    "requestedByChatMessageId",
+    "runId",
+    "promptedAction",
+    "payloadRef",
+]);
+// `payloadRef` carries strictly envelope-id refs and nothing else. The branded
+// `sourceEnvelopeIds` array is the only permitted member.
+const ALLOWED_PAYLOAD_REF_KEYS = new Set(["sourceEnvelopeIds"]);
+const errResult = (status, code) => ({
+    status,
+    body: qiHandoffErrorBody(code),
+});
+const scanForbiddenStrings = (value) => {
+    if (typeof value === "string")
+        return containsForbiddenSecretShape(value);
+    if (Array.isArray(value))
+        return value.some(scanForbiddenStrings);
+    if (isPlainObject(value)) {
+        for (const v of Object.values(value)) {
+            if (scanForbiddenStrings(v))
+                return true;
+        }
+        return false;
+    }
+    return false;
+};
+const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+const isAllowedAction = (value) => {
+    if (typeof value !== "string")
+        return false;
+    for (const action of QualityIntelligence.QUALITY_INTELLIGENCE_HANDOFF_PROMPTED_ACTIONS) {
+        if (action === value)
+            return true;
+    }
+    return false;
+};
+const fail = (code = "QI_HANDOFF_BAD_REQUEST") => ({
+    kind: "err",
+    result: errResult(400, code),
+});
+const hasOnlyAllowedKeys = (obj, allowed) => {
+    for (const key of Object.keys(obj)) {
+        if (!allowed.has(key))
+            return false;
+    }
+    return true;
+};
+const parseSourceEnvelopeIds = (raw) => {
+    if (!Array.isArray(raw))
+        return undefined;
+    const ids = [];
+    for (const candidate of raw) {
+        if (typeof candidate !== "string")
+            return undefined;
+        try {
+            ids.push(QualityIntelligence.asQualityIntelligenceSourceEnvelopeId(candidate));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return ids;
+};
+const parseOptionalRunId = (raw) => {
+    if (raw === undefined)
+        return { ok: true, value: undefined };
+    if (typeof raw !== "string")
+        return { ok: false };
+    try {
+        return { ok: true, value: QualityIntelligence.asQualityIntelligenceRunId(raw) };
+    }
+    catch {
+        return { ok: false };
+    }
+};
+const validatePayloadRef = (raw) => {
+    if (!isPlainObject(raw))
+        return undefined;
+    if (!hasOnlyAllowedKeys(raw, ALLOWED_PAYLOAD_REF_KEYS))
+        return undefined;
+    return parseSourceEnvelopeIds(raw.sourceEnvelopeIds);
+};
+const validateEnvelope = (parsed) => {
+    if (!isPlainObject(parsed))
+        return fail();
+    if (!hasOnlyAllowedKeys(parsed, ALLOWED_ENVELOPE_KEYS))
+        return fail();
+    if (!isNonEmptyString(parsed.id))
+        return fail();
+    if (!isNonEmptyString(parsed.requestedByChatMessageId))
+        return fail();
+    if (!isAllowedAction(parsed.promptedAction))
+        return fail();
+    const sourceEnvelopeIds = validatePayloadRef(parsed.payloadRef);
+    if (sourceEnvelopeIds === undefined)
+        return fail();
+    const runIdResult = parseOptionalRunId(parsed.runId);
+    if (!runIdResult.ok)
+        return fail();
+    // Defence-in-depth: scrub every string value for credential-shaped substrings.
+    if (scanForbiddenStrings(parsed))
+        return fail("QI_HANDOFF_FORBIDDEN_PAYLOAD");
+    const envelope = {
+        id: parsed.id,
+        requestedByChatMessageId: parsed.requestedByChatMessageId,
+        promptedAction: parsed.promptedAction,
+        payloadRef: { sourceEnvelopeIds },
+        ...(runIdResult.value !== undefined ? { runId: runIdResult.value } : {}),
+    };
+    return { kind: "ok", envelope };
+};
+// Single indexed lookup — replaces O(P×C×M) triple scan on every handoff POST.
+const findChatMessage = (deps, messageId) => {
+    const message = deps.store.findMessageById(messageId);
+    if (message === undefined)
+        return undefined;
+    return { chatId: message.chatId, message };
+};
+// ─── Persisted handoff record ──────────────────────────────────────────────────
+//
+// We persist the handoff as a single system message on the owning chat. The message
+// content is a fixed, non-echoing descriptor — the envelope itself is NOT serialised
+// into the message body. This preserves the envelope-only invariant on the persisted
+// row and keeps the chat surface free of secret-shaped content.
+const HANDOFF_TASK_TYPE = "qi-handoff";
+const HANDOFF_CONTENT_BY_ACTION = {
+    "design-tests": "Quality Intelligence: design-tests handoff requested.",
+    "validate-tests": "Quality Intelligence: validate-tests handoff requested.",
+    "review-coverage": "Quality Intelligence: review-coverage handoff requested.",
+    "request-export": "Quality Intelligence: request-export handoff requested.",
+};
+const buildHandoffMessage = (resolved, envelope, now, linkedRunId) => ({
+    chatId: resolved.chatId,
+    role: "system",
+    content: HANDOFF_CONTENT_BY_ACTION[envelope.promptedAction],
+    timestamp: now(),
+    runId: linkedRunId,
+    workflowId: undefined,
+    workflowStatus: undefined,
+    shortResult: undefined,
+    taskType: HANDOFF_TASK_TYPE,
+});
+// For a "design-tests" handoff, start a model-routed QI run in the BACKGROUND from the chat's
+// connected workspace context. Fire-and-forget: the run registers with the in-flight registry (so it
+// surfaces in the run list) and persists to evidence on completion; the handoff returns the run id
+// immediately so the Conversation Center can link + poll it. The run goes through the Keiko Model
+// Gateway + Harness like any QI run — this is the governed workflow handoff (Issue #281), not a
+// parallel chat/agent/model path.
+//
+// Multi-source (Epic #532/#729): a chat may connect more than one folder. The run ingests EVERY
+// connected workspace root so the QI run covers the full context the user connected — not just the
+// first folder. `executeQiRun` already applies the per-run source cap, deny-list guard, and byte
+// budget over the source list.
+//
+// `envelope.payloadRef.sourceEnvelopeIds` are reserved for a future capability that narrows the run
+// to a user-selected SUBSET of the connected context; until that resolver exists the run faithfully
+// ingests the chat's whole connected workspace context, so an empty (or any) id list is honoured by
+// using the connected scopes.
+const startHandoffRun = (deps, roots) => {
+    const runId = `qi-run-${randomUUID()}`;
+    const registeredAt = new Date().toISOString();
+    const controller = qiRunRegistry.register(runId, registeredAt);
+    const totals = { candidates: 0, findings: 0, exports: 0 };
+    void executeQiRun({
+        request: {
+            sources: roots.map((path) => ({
+                kind: "workspace",
+                label: "Conversation Center",
+                path,
+            })),
+        },
+        runId,
+        deps,
+        registeredAt,
+        signal: controller.signal,
+        onAccepted: () => undefined,
+        onEvent: (event) => {
+            if (event.payload.kind === "candidate:proposed")
+                totals.candidates += 1;
+            if (event.payload.kind === "finding:recorded")
+                totals.findings += 1;
+            qiRunRegistry.updateTotals(runId, totals);
+        },
+    })
+        .then((summary) => {
+        qiRunRegistry.complete(runId, summary.status);
+    })
+        .catch(() => {
+        qiRunRegistry.complete(runId, "failed");
+    });
+    return runId;
+};
+// Collect the distinct, non-empty absolute roots of a chat's connected workspace context. Prefers
+// the canonical multi-source `connectedScopes` list (Epic #532); falls back to the legacy singular
+// `connectedScope` for older chats. Non-folder scopes (no `root`) are skipped — the handoff run
+// ingests workspace folders only. Order-preserving exact-string de-duplication.
+const collectConnectedRoots = (chat) => {
+    const scopes = chat?.connectedScopes ?? (chat?.connectedScope !== undefined ? [chat.connectedScope] : []);
+    const roots = [];
+    for (const scope of scopes) {
+        const root = scope.root;
+        if (typeof root === "string" && root.length > 0 && !roots.includes(root)) {
+            roots.push(root);
+        }
+    }
+    return roots;
+};
+// Resolve the run id linked to a handoff: a "design-tests" handoff over a chat with a connected
+// workspace context starts a background run; otherwise it falls back to any run id the envelope
+// already carried.
+const resolveHandoffRunId = (deps, envelope, chatId) => {
+    if (envelope.promptedAction !== "design-tests")
+        return envelope.runId;
+    const chat = deps.store.findChatById(chatId);
+    const roots = collectConnectedRoots(chat);
+    if (roots.length > 0)
+        return startHandoffRun(deps, roots);
+    return envelope.runId;
+};
+export const createHandleQiHandoff = (options = {}) => {
+    const now = options.now ?? (() => Date.now());
+    return async (ctx, deps) => {
+        let raw;
+        try {
+            raw = await readBody(ctx.req);
+        }
+        catch (e) {
+            if (e instanceof BodyTooLargeError) {
+                return errResult(413, "QI_HANDOFF_PAYLOAD_TOO_LARGE");
+            }
+            return errResult(400, "QI_HANDOFF_BAD_REQUEST");
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return errResult(400, "QI_HANDOFF_BAD_REQUEST");
+        }
+        const validation = validateEnvelope(parsed);
+        if (validation.kind === "err")
+            return validation.result;
+        const { envelope } = validation;
+        const resolved = findChatMessage(deps, envelope.requestedByChatMessageId);
+        if (resolved === undefined) {
+            return errResult(404, "QI_HANDOFF_UNKNOWN_CHAT_MESSAGE");
+        }
+        const linkedRunId = resolveHandoffRunId(deps, envelope, resolved.chatId);
+        const persisted = deps.store.createMessage(buildHandoffMessage(resolved, envelope, now, linkedRunId));
+        const body = {
+            handoffId: envelope.id,
+            chatId: resolved.chatId,
+            persistedMessageId: persisted.id,
+            ...(linkedRunId !== undefined ? { runId: linkedRunId } : {}),
+        };
+        return { status: 200, body };
+    };
+};
+export const handleQiHandoff = createHandleQiHandoff();
+// Mechanically-mergeable route group. Sibling QI epic work (e.g. #280) registers its
+// own group separately; the dispatcher in `routes.ts` spreads each group into the
+// route table, so the merge surface here is a single array literal.
+export const QI_HANDOFF_ROUTE_GROUP = [
+    {
+        method: "POST",
+        pattern: "/api/quality-intelligence/handoff",
+        handler: handleQiHandoff,
+    },
+];

package/dist/qualityIntelligence/index.d.ts

@@ -0,0 +1,17 @@
+export { isFigmaConnectorAuthorized, isJiraConnectorAuthorized, summariseQiConnectorCapabilities, type QiConnectorCapabilities, type QiConnectorConfig, } from "./connectorAuthorization.js";
+export { payloadContainsForbiddenSecretShape, qiConnectorErrorBody, type QiConnectorErrorBody, type QiConnectorErrorCode, } from "./connectorErrors.js";
+export { handleQiCapabilities, handleQiDryRunFigma, handleQiDryRunJira, handleQiSourceSelect, } from "./connectorRoutes.js";
+export { handleListQiRuns, handleGetQiRun } from "./uiRoutes.js";
+export { QI_HANDOFF_ROUTE_GROUP, createHandleQiHandoff, handleQiHandoff, type QiHandoffRouteOptions, type QiHandoffSuccessBody, } from "./handoffRoutes.js";
+export { qiHandoffErrorBody, type QiHandoffErrorBody, type QiHandoffErrorCode, } from "./handoffErrors.js";
+export { QI_RUN_EXECUTION_ROUTE_GROUP, handleStartQiRun, handleCancelQiRun } from "./runRoutes.js";
+export { qiRunRegistry, QiRunRegistry } from "./runRegistry.js";
+export { executeQiRun, QiIngestionError, QiGenerationError } from "./runExecution.js";
+export { applyReviewDecision, appendEditAudit, loadRunReviewState, runReviewStateOf, candidateReviewStateOf, type QiReviewAction, type QiAuditAction, type QiReviewStateArtifact, } from "./reviewStore.js";
+export { QI_REVIEW_ROUTE_GROUP, handleQiReview } from "./reviewRoutes.js";
+export { QI_EXPORT_ROUTE_GROUP, handleQiExport } from "./exportRoutes.js";
+export { QI_EDIT_ROUTE_GROUP, handleQiEditCandidate } from "./editRoutes.js";
+export { QI_RETENTION_ROUTE_GROUP, handleQiDeleteRun } from "./retentionRoutes.js";
+export { QI_TRACEABILITY_ROUTE_GROUP, handleQiTraceabilityExport } from "./traceabilityRoutes.js";
+export { QI_RECHECK_ROUTE_GROUP, handleQiReCheck, handleQiRegenerateStale, } from "./reCheckRoutes.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mCAAmC,EACnC,oBAAoB,EACpB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,eAAe,EACf,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,4BAA4B,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnG,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtF,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7E,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEnF,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAElG,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,uBAAuB,GACxB,MAAM,oBAAoB,CAAC"}

package/dist/qualityIntelligence/index.js

@@ -0,0 +1,36 @@
+// Public barrel for the keiko-server Quality Intelligence connector route group
+// (Epic #270, Issue #278).
+//
+// Re-exports the additive connector route handlers, the authorisation predicates,
+// and the safe-error helpers so the server route registrar can mount them as one
+// cohesive group. The route group is DISABLED BY DEFAULT — every connector
+// authorisation predicate returns `false` unless explicit config flips it.
+//
+// Nothing in this barrel performs IO or imports a provider SDK; the runtime
+// behaviour lives in the existing keiko-server route plumbing.
+export { isFigmaConnectorAuthorized, isJiraConnectorAuthorized, summariseQiConnectorCapabilities, } from "./connectorAuthorization.js";
+export { payloadContainsForbiddenSecretShape, qiConnectorErrorBody, } from "./connectorErrors.js";
+export { handleQiCapabilities, handleQiDryRunFigma, handleQiDryRunJira, handleQiSourceSelect, } from "./connectorRoutes.js";
+// Issue #280 — read-only UI routes for the Quality Intelligence panel.
+export { handleListQiRuns, handleGetQiRun } from "./uiRoutes.js";
+// Issue #281 — Conversation Center → QI workflow handoff route group.
+export { QI_HANDOFF_ROUTE_GROUP, createHandleQiHandoff, handleQiHandoff, } from "./handoffRoutes.js";
+export { qiHandoffErrorBody, } from "./handoffErrors.js";
+// Issue #273/#280 — QI run execution (start + cancel) route group + in-flight registry.
+export { QI_RUN_EXECUTION_ROUTE_GROUP, handleStartQiRun, handleCancelQiRun } from "./runRoutes.js";
+export { qiRunRegistry, QiRunRegistry } from "./runRegistry.js";
+export { executeQiRun, QiIngestionError, QiGenerationError } from "./runExecution.js";
+// Issue #282 — review-state companion store (read + mutation seams).
+export { applyReviewDecision, appendEditAudit, loadRunReviewState, runReviewStateOf, candidateReviewStateOf, } from "./reviewStore.js";
+// Issue #282 — review-action route group.
+export { QI_REVIEW_ROUTE_GROUP, handleQiReview } from "./reviewRoutes.js";
+// Issue #283 — export route group (local serialise + TMS dry-run preview).
+export { QI_EXPORT_ROUTE_GROUP, handleQiExport } from "./exportRoutes.js";
+// Issue #726 (Epic #712) — inline-edit route group.
+export { QI_EDIT_ROUTE_GROUP, handleQiEditCandidate } from "./editRoutes.js";
+// Issue #282 follow-up — run-deletion control route group (DELETE /runs/:id, ADR-0023 D8).
+export { QI_RETENTION_ROUTE_GROUP, handleQiDeleteRun } from "./retentionRoutes.js";
+// Issue #740 (Epic #734) — requirement↔test traceability matrix export route group.
+export { QI_TRACEABILITY_ROUTE_GROUP, handleQiTraceabilityExport } from "./traceabilityRoutes.js";
+// Issue #743 (Epic #735) — drift re-check + targeted regeneration route group.
+export { QI_RECHECK_ROUTE_GROUP, handleQiReCheck, handleQiRegenerateStale, } from "./reCheckRoutes.js";

package/dist/qualityIntelligence/judgePort.d.ts

@@ -0,0 +1,30 @@
+import { type ChatMessage } from "@oscharko-dev/keiko-model-gateway";
+import type { TestQualityJudgeVerdict } from "@oscharko-dev/keiko-contracts";
+import type { UiHandlerDeps } from "../deps.js";
+export declare class QiJudgeError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+interface JudgeSourceContext {
+    readonly atomId: string;
+    readonly text: string;
+}
+interface JudgePromptInput {
+    readonly candidateText: string;
+    readonly sourceContext: readonly JudgeSourceContext[];
+}
+export declare function scrubCandidateText(text: string): string;
+export declare function buildJudgePrompt(candidateText: string, sourceContext?: readonly JudgeSourceContext[]): readonly ChatMessage[];
+export declare function parseJudgeVerdict(rawText: string): TestQualityJudgeVerdict;
+export interface QiJudgePort {
+    readonly judge: (input: JudgePromptInput, signal?: AbortSignal) => Promise<TestQualityJudgeVerdict & {
+        readonly gatewayCallCount: number;
+    }>;
+}
+/**
+ * Build a judge port bound to one model id. Applies the qi:judge-logic capability gate
+ * (chat model with text capability). Gateway-only; no direct provider calls.
+ */
+export declare function createQiJudgePort(deps: UiHandlerDeps, modelId: string): QiJudgePort;
+export {};
+//# sourceMappingURL=judgePort.d.ts.map

package/dist/qualityIntelligence/judgePort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judgePort.d.ts","sourceRoot":"","sources":["../../src/qualityIntelligence/judgePort.ts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,WAAW,EAGjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,KAAK,EAEV,uBAAuB,EAExB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBACjB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK1C;AAQD,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,gBAAgB;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACvD;AAgCD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASvD;AAyBD,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EACrB,aAAa,GAAE,SAAS,kBAAkB,EAAO,GAChD,SAAS,WAAW,EAAE,CAsBxB;AAmKD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB,CAW1E;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,CACd,KAAK,EAAE,gBAAgB,EACvB,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,uBAAuB,GAAG;QAAE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAqDnF"}