@mcoda/codali 0.1.88 → 0.1.89

package/dist/gateway/EvidenceNormalizer.js

@@ -0,0 +1,488 @@
+import { createHash } from "node:crypto";
+const MAX_DEPTH = 5;
+const MAX_EXCERPT_CHARS = 1200;
+const EVIDENCE_ARRAY_KEYS = [
+    "evidence",
+    "evidenceItems",
+    "evidence_items",
+    "facts",
+    "sources",
+    "sourceRecords",
+    "source_records",
+    "citations",
+    "results",
+    "hits",
+    "items",
+    "records",
+];
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const readString = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return String(value);
+        }
+    }
+    return undefined;
+};
+const readNumber = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string" && value.trim()) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+};
+const readBoolean = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return undefined;
+};
+const readRecord = (record, keys) => {
+    for (const key of keys) {
+        const value = record[key];
+        if (isRecord(value)) {
+            return value;
+        }
+    }
+    return undefined;
+};
+const clamp = (value, fallback) => {
+    const candidate = Number.isFinite(value) ? value : fallback;
+    return Math.max(0, Math.min(1, candidate));
+};
+const truncate = (value) => {
+    if (!value)
+        return undefined;
+    return value.length > MAX_EXCERPT_CHARS
+        ? `${value.slice(0, MAX_EXCERPT_CHARS - 3)}...`
+        : value;
+};
+const canonicalize = (value) => (value ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+const stableHash = (value) => createHash("sha256").update(value).digest("hex").slice(0, 16);
+const stableEvidenceId = (runId, taskId, candidate) => {
+    const fingerprint = [
+        runId,
+        taskId ?? "",
+        canonicalize(candidate.sourceType),
+        canonicalize(candidate.sourceId),
+        canonicalize(candidate.sourceUri),
+        canonicalize(candidate.sourceTitle),
+        canonicalize(candidate.claim),
+    ].join("|");
+    return `ev-${stableHash(fingerprint)}`;
+};
+const fingerprintCandidate = (candidate) => [
+    canonicalize(candidate.sourceType),
+    canonicalize(candidate.sourceId),
+    canonicalize(candidate.sourceUri),
+    canonicalize(candidate.sourceTitle),
+    canonicalize(candidate.claim),
+].join("|");
+const metadataFromRecord = (record) => isRecord(record.metadata) ? record.metadata : undefined;
+const sourceRecord = (record) => readRecord(record, ["source", "provenance", "citation"]);
+const docdexTelemetryMetadata = (record) => {
+    if (!record)
+        return undefined;
+    const requestId = readString(record, [
+        "docdex_request_id",
+        "docdexRequestId",
+        "request_id",
+        "requestId",
+        "x-docdex-request-id",
+        "x_docdex_request_id",
+        "x-request-id",
+        "x_request_id",
+        "correlation_id",
+        "correlationId",
+    ]);
+    const operation = readString(record, ["docdex_operation", "docdexOperation", "operation"]);
+    const metadata = {};
+    if (requestId)
+        metadata.docdex_request_id = requestId;
+    if (operation)
+        metadata.docdex_operation = operation;
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+};
+const mergeDocdexTelemetryMetadata = (base, ...records) => {
+    const metadata = { ...(base ?? {}) };
+    for (const record of records) {
+        Object.assign(metadata, docdexTelemetryMetadata(record) ?? {});
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+};
+const sourceTypeFromTool = (tool) => {
+    if (!tool)
+        return undefined;
+    if (tool.startsWith("docdex_"))
+        return "docdex";
+    return "app_tool";
+};
+const hasDocdexShape = (record) => Boolean(readString(record, ["doc_id", "docId", "documentId"]) ||
+    readString(record, ["rel_path", "relPath", "path", "file"]) ||
+    readString(record, ["snippet", "excerpt"]));
+const provenancePresent = (candidate) => Boolean(candidate.sourceId ||
+    candidate.sourceUri ||
+    candidate.sourceTitle ||
+    candidate.rawExcerpt ||
+    candidate.usedTool);
+const safeJsonExcerpt = (value) => {
+    try {
+        return truncate(JSON.stringify(value));
+    }
+    catch {
+        return undefined;
+    }
+};
+const parseMaybeJson = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return { malformed: false };
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return { malformed: false };
+    }
+    try {
+        return { parsed: JSON.parse(trimmed), malformed: false };
+    }
+    catch {
+        return { malformed: true };
+    }
+};
+const buildCandidateFromRecord = (record, context) => {
+    const source = sourceRecord(record);
+    const docdexLike = hasDocdexShape(record);
+    const sourceType = readString(record, ["sourceType", "source_type", "type"]) ??
+        (source ? readString(source, ["sourceType", "source_type", "type"]) : undefined) ??
+        (docdexLike ? "docdex" : context.sourceType);
+    const sourceId = readString(record, ["sourceId", "source_id", "doc_id", "docId", "documentId", "id"]) ??
+        (source ? readString(source, ["sourceId", "source_id", "doc_id", "docId", "id"]) : undefined);
+    const sourceUri = readString(record, ["sourceUri", "source_uri", "url", "uri", "href"]) ??
+        (source ? readString(source, ["sourceUri", "source_uri", "url", "uri", "href"]) : undefined);
+    const sourceTitle = readString(record, ["sourceTitle", "source_title", "title", "name", "rel_path", "relPath", "path", "file"]) ??
+        (source ? readString(source, ["sourceTitle", "source_title", "title", "name", "path"]) : undefined);
+    const rawExcerpt = truncate(readString(record, ["rawExcerpt", "raw_excerpt", "excerpt", "snippet", "text"])) ??
+        (source ? truncate(readString(source, ["rawExcerpt", "raw_excerpt", "excerpt", "snippet", "text"])) : undefined);
+    const claim = readString(record, ["claim", "fact", "statement", "summary", "description", "text", "content"]) ??
+        rawExcerpt ??
+        sourceTitle;
+    if (!claim) {
+        return undefined;
+    }
+    const tenantScoped = readBoolean(record, ["tenantScoped", "tenant_scoped"]) ??
+        (source ? readBoolean(source, ["tenantScoped", "tenant_scoped"]) : undefined) ??
+        context.tenantScoped;
+    const usedTool = readString(record, ["usedTool", "used_tool", "tool"]) ??
+        context.usedTool;
+    const recordMetadata = metadataFromRecord(record);
+    const metadata = {
+        ...(context.metadata ?? {}),
+        ...(recordMetadata ?? {}),
+        ...(docdexTelemetryMetadata(record) ?? {}),
+        ...(docdexTelemetryMetadata(recordMetadata) ?? {}),
+        ...(source ? docdexTelemetryMetadata(source) ?? {} : {}),
+    };
+    const path = readString(record, ["rel_path", "relPath", "path", "file"]);
+    if (path)
+        metadata.path = path;
+    if (source && Object.keys(source).length > 0)
+        metadata.source = source;
+    const unprovenanced = !provenancePresent({
+        sourceId,
+        sourceUri,
+        sourceTitle,
+        rawExcerpt,
+        usedTool,
+    });
+    return {
+        claim,
+        summary: readString(record, ["summary"]),
+        sourceType: sourceType ?? (unprovenanced ? "model_observation" : "worker_output"),
+        sourceId,
+        sourceUri,
+        sourceTitle,
+        sourceTimestamp: readString(record, ["sourceTimestamp", "source_timestamp", "timestamp", "updatedAt", "updated_at"]) ??
+            (source ? readString(source, ["sourceTimestamp", "source_timestamp", "timestamp", "updatedAt", "updated_at"]) : undefined),
+        rawExcerpt,
+        rawPayloadRef: readString(record, ["rawPayloadRef", "raw_payload_ref"]),
+        confidence: readNumber(record, ["confidence", "score"]),
+        relevance: readNumber(record, ["relevance", "rankScore", "rank_score", "score"]),
+        freshness: readFreshness(record),
+        usedTool,
+        tenantScoped,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        value: record,
+        unprovenanced,
+    };
+};
+const readFreshness = (record) => {
+    const freshness = readString(record, ["freshness"]);
+    if (freshness === "fresh" ||
+        freshness === "recent" ||
+        freshness === "stale" ||
+        freshness === "unknown") {
+        return freshness;
+    }
+    return undefined;
+};
+const collectCandidates = (value, context, warnings) => {
+    if (context.depth > MAX_DEPTH || value === undefined || value === null) {
+        return [];
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return [];
+        const parsed = parseMaybeJson(trimmed);
+        if (parsed.parsed !== undefined) {
+            return collectCandidates(parsed.parsed, { ...context, depth: context.depth + 1 }, warnings);
+        }
+        if (parsed.malformed) {
+            warnings.push("malformed_worker_json");
+        }
+        if (!context.rootStringMode) {
+            return [];
+        }
+        return [{
+                claim: trimmed,
+                rawExcerpt: truncate(trimmed),
+                sourceType: "model_observation",
+                confidence: 0.2,
+                relevance: 0.4,
+                usedTool: context.usedTool,
+                tenantScoped: context.tenantScoped,
+                metadata: context.metadata,
+                value,
+                unprovenanced: true,
+            }];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectCandidates(item, {
+            ...context,
+            depth: context.depth + 1,
+            rootStringMode: true,
+        }, warnings));
+    }
+    if (!isRecord(value)) {
+        return [];
+    }
+    const recordMetadata = metadataFromRecord(value);
+    const metaRecord = readRecord(value, ["meta"]);
+    const scopedMetadata = mergeDocdexTelemetryMetadata(context.metadata, value, recordMetadata, metaRecord);
+    const scopedContext = scopedMetadata
+        ? { ...context, metadata: scopedMetadata }
+        : context;
+    const candidates = [];
+    const directCandidate = buildCandidateFromRecord(value, scopedContext);
+    if (directCandidate) {
+        candidates.push(directCandidate);
+    }
+    for (const key of EVIDENCE_ARRAY_KEYS) {
+        const child = value[key];
+        if (child === undefined)
+            continue;
+        candidates.push(...collectCandidates(child, {
+            ...scopedContext,
+            depth: context.depth + 1,
+            rootStringMode: key === "facts",
+        }, warnings));
+    }
+    if (candidates.length === 0 && context.allowGenericPayload && Object.keys(value).length > 0) {
+        candidates.push({
+            claim: context.usedTool
+                ? `Tool ${context.usedTool} returned structured data.`
+                : "Worker returned structured data.",
+            summary: safeJsonExcerpt(value),
+            sourceType: context.sourceType ?? "app_tool",
+            rawExcerpt: safeJsonExcerpt(value),
+            confidence: 0.55,
+            relevance: 0.5,
+            usedTool: scopedContext.usedTool,
+            tenantScoped: scopedContext.tenantScoped,
+            metadata: scopedContext.metadata,
+            value,
+        });
+    }
+    return candidates;
+};
+const normalizeCandidate = (input, candidate) => {
+    const claim = candidate.claim?.trim();
+    if (!claim) {
+        return undefined;
+    }
+    const unprovenanced = candidate.unprovenanced || !provenancePresent(candidate);
+    const sourceType = unprovenanced
+        ? "model_observation"
+        : candidate.sourceType ?? input.defaultSourceType ?? "worker_output";
+    const fallbackConfidence = sourceType === "model_observation"
+        ? 0.2
+        : sourceType === "docdex"
+            ? 0.75
+            : sourceType === "app_tool"
+                ? 0.7
+                : 0.55;
+    const fallbackRelevance = sourceType === "model_observation"
+        ? 0.4
+        : sourceType === "docdex"
+            ? 0.65
+            : 0.55;
+    const confidence = unprovenanced
+        ? Math.min(0.25, clamp(candidate.confidence, fallbackConfidence))
+        : clamp(candidate.confidence, fallbackConfidence);
+    const relevance = clamp(candidate.relevance, fallbackRelevance);
+    return {
+        id: stableEvidenceId(input.runId, input.taskId, { ...candidate, claim, sourceType }),
+        runId: input.runId,
+        taskId: input.taskId,
+        stageId: input.stageId,
+        claim,
+        summary: candidate.summary,
+        sourceType,
+        sourceId: candidate.sourceId,
+        sourceUri: candidate.sourceUri,
+        sourceTitle: candidate.sourceTitle,
+        sourceTimestamp: candidate.sourceTimestamp,
+        rawExcerpt: candidate.rawExcerpt,
+        rawPayloadRef: candidate.rawPayloadRef,
+        confidence,
+        relevance,
+        freshness: candidate.freshness,
+        usedTool: candidate.usedTool ?? input.defaultTool,
+        tenantScoped: candidate.tenantScoped ?? input.defaultTenantScoped ?? false,
+        metadata: {
+            ...(candidate.metadata ?? {}),
+            normalizedBy: "codali_gateway_evidence_normalizer",
+            unprovenanced,
+            originalQuery: input.originalQuery,
+        },
+    };
+};
+export const normalizeCodaliEvidence = (input) => {
+    const warnings = [];
+    const rejected = [];
+    const candidates = [];
+    for (const evidence of input.evidence ?? []) {
+        candidates.push(...collectCandidates(evidence, {
+            sourceType: input.defaultSourceType,
+            usedTool: input.defaultTool,
+            tenantScoped: input.defaultTenantScoped,
+            depth: 0,
+            rootStringMode: true,
+        }, warnings));
+    }
+    if (input.workerOutput !== undefined) {
+        candidates.push(...collectCandidates(input.workerOutput, {
+            sourceType: input.defaultSourceType,
+            usedTool: input.defaultTool,
+            tenantScoped: input.defaultTenantScoped,
+            depth: 0,
+            rootStringMode: true,
+        }, warnings));
+    }
+    for (const call of input.toolCalls ?? []) {
+        if (call.status && call.status !== "success") {
+            continue;
+        }
+        const toolSourceType = sourceTypeFromTool(call.tool) ?? input.defaultSourceType;
+        const before = candidates.length;
+        candidates.push(...collectCandidates(call.result, {
+            sourceType: toolSourceType,
+            usedTool: call.tool,
+            tenantScoped: input.defaultTenantScoped,
+            metadata: {
+                tool: call.tool,
+                toolArgs: call.args,
+                toolMetadata: call.metadata,
+            },
+            depth: 0,
+            rootStringMode: false,
+            allowGenericPayload: toolSourceType === "app_tool",
+        }, warnings));
+        if (candidates.length === before &&
+            toolSourceType === "app_tool" &&
+            call.result !== undefined) {
+            candidates.push({
+                claim: `Tool ${call.tool} returned structured data.`,
+                sourceType: "app_tool",
+                rawExcerpt: safeJsonExcerpt(call.result),
+                confidence: 0.55,
+                relevance: 0.5,
+                usedTool: call.tool,
+                tenantScoped: input.defaultTenantScoped,
+                metadata: { tool: call.tool, toolArgs: call.args, toolMetadata: call.metadata },
+                value: call.result,
+            });
+        }
+    }
+    const deduped = new Map();
+    let duplicateCount = 0;
+    for (const candidate of candidates) {
+        const normalized = normalizeCandidate(input, candidate);
+        if (!normalized) {
+            rejected.push({
+                reason: "missing_claim",
+                value: candidate.value,
+            });
+            continue;
+        }
+        if (input.requireTenantScope && !normalized.tenantScoped) {
+            rejected.push({
+                reason: "tenant_scope_required",
+                claim: normalized.claim,
+                sourceType: normalized.sourceType,
+                sourceId: normalized.sourceId,
+                sourceUri: normalized.sourceUri,
+                usedTool: normalized.usedTool,
+                value: candidate.value,
+            });
+            continue;
+        }
+        const fingerprint = fingerprintCandidate(normalized);
+        const existing = deduped.get(fingerprint);
+        if (existing) {
+            duplicateCount += 1;
+            existing.metadata = {
+                ...(existing.metadata ?? {}),
+                duplicateCount: Number(existing.metadata?.duplicateCount ?? 0) + 1,
+                duplicateEvidenceIds: [
+                    ...(Array.isArray(existing.metadata?.duplicateEvidenceIds)
+                        ? existing.metadata.duplicateEvidenceIds
+                        : []),
+                    normalized.id,
+                ],
+            };
+            existing.confidence = Math.max(existing.confidence, normalized.confidence);
+            existing.relevance = Math.max(existing.relevance, normalized.relevance);
+            continue;
+        }
+        deduped.set(fingerprint, normalized);
+    }
+    const evidence = [...deduped.values()]
+        .sort((left, right) => right.relevance - left.relevance ||
+        right.confidence - left.confidence ||
+        left.id.localeCompare(right.id))
+        .slice(0, Math.max(0, input.maxEvidenceItems ?? Number.MAX_SAFE_INTEGER));
+    if ((input.maxEvidenceItems ?? Number.MAX_SAFE_INTEGER) < deduped.size) {
+        warnings.push("evidence_truncated_to_budget");
+    }
+    return {
+        evidence,
+        rejected,
+        warnings,
+        duplicateCount,
+    };
+};
+export const normalizeGatewayEvidence = normalizeCodaliEvidence;

package/dist/gateway/GatewayPlanner.d.ts

@@ -0,0 +1,195 @@
+import type { Provider, ProviderMessage } from "../providers/ProviderTypes.js";
+import type { CodaliGatewayClassifierOutput, CodaliGatewayPlannerOutput, CodaliGatewayRequest, CodaliGatewayValidationIssue } from "./CodaliGatewayTypes.js";
+import { type GatewayPolicyCompilation } from "./GatewayPolicyCompiler.js";
+export interface CodaliGatewayPlannerToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+export interface GatewayPlannerInput {
+    request: CodaliGatewayRequest;
+    policyCompilation?: GatewayPolicyCompilation;
+    toolDescriptions?: Record<string, string | CodaliGatewayPlannerToolDescriptor>;
+}
+export interface CodaliGatewayPlanningResult {
+    policyCompilation: GatewayPolicyCompilation;
+    classifier: CodaliGatewayClassifierOutput;
+    planner: CodaliGatewayPlannerOutput;
+    warnings: string[];
+    classifierRepairAttempts: number;
+    plannerRepairAttempts: number;
+    classifierRawContent: string;
+    plannerRawContent: string;
+}
+export interface CodaliGatewayPlannerOptions {
+    maxRepairAttempts?: number;
+    maxTokens?: number;
+    temperature?: number;
+}
+export declare class CodaliGatewayPlannerError extends Error {
+    readonly code: string;
+    readonly issues?: CodaliGatewayValidationIssue[];
+    constructor(code: string, message: string, issues?: CodaliGatewayValidationIssue[]);
+}
+export declare const CODALI_GATEWAY_CLASSIFIER_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["queryType", "needsPrivateData", "needsFreshData", "needsDocdex", "needsAppTools", "needsImageWorker"];
+    readonly properties: {
+        readonly queryType: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly needsPrivateData: {
+            readonly type: "boolean";
+        };
+        readonly needsFreshData: {
+            readonly type: "boolean";
+        };
+        readonly needsDocdex: {
+            readonly type: "boolean";
+        };
+        readonly needsAppTools: {
+            readonly type: "boolean";
+        };
+        readonly needsImageWorker: {
+            readonly type: "boolean";
+        };
+        readonly directAnswerCandidate: {
+            readonly type: "string";
+        };
+        readonly rationale: {
+            readonly type: "string";
+        };
+        readonly confidence: {
+            readonly enum: readonly ["high", "medium", "low"];
+        };
+        readonly metadata: {
+            readonly type: "object";
+        };
+    };
+};
+export declare const CODALI_GATEWAY_PLANNER_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["queryType", "subquestions", "workerTasks"];
+    readonly properties: {
+        readonly runId: {
+            readonly type: "string";
+        };
+        readonly queryType: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly subquestions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["id", "question"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly question: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly rationale: {
+                        readonly type: "string";
+                    };
+                    readonly priority: {
+                        readonly type: "number";
+                    };
+                };
+            };
+        };
+        readonly workerTasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["id", "workerRole", "objective", "toolsAllowed", "outputFormat"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly workerRole: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly objective: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly query: {
+                        readonly type: "string";
+                    };
+                    readonly toolsAllowed: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly outputFormat: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly expectedSources: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly priority: {
+                        readonly type: "number";
+                    };
+                    readonly metadata: {
+                        readonly type: "object";
+                    };
+                };
+            };
+        };
+        readonly expectedEvidenceCount: {
+            readonly type: "number";
+        };
+        readonly maxIterations: {
+            readonly type: "number";
+        };
+        readonly requiresFinalLargeModel: {
+            readonly type: "boolean";
+        };
+        readonly metadata: {
+            readonly type: "object";
+        };
+    };
+};
+export declare const buildCodaliGatewayClassifierMessages: (input: GatewayPlannerInput) => ProviderMessage[];
+export declare const buildCodaliGatewayPlannerMessages: (input: GatewayPlannerInput, classifier: CodaliGatewayClassifierOutput) => ProviderMessage[];
+export declare class CodaliGatewayPlanner {
+    private readonly provider;
+    private readonly options;
+    private readonly maxRepairAttempts;
+    constructor(provider: Provider, options?: CodaliGatewayPlannerOptions);
+    classify(input: GatewayPlannerInput): Promise<{
+        classifier: CodaliGatewayClassifierOutput;
+        repairAttempts: number;
+        rawContent: string;
+        warnings: string[];
+    }>;
+    plan(input: GatewayPlannerInput): Promise<CodaliGatewayPlanningResult>;
+    private generateValidated;
+}
+export declare const createCodaliGatewayPlanner: (provider: Provider, options?: CodaliGatewayPlannerOptions) => CodaliGatewayPlanner;
+//# sourceMappingURL=GatewayPlanner.d.ts.map

package/dist/gateway/GatewayPlanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayPlanner.d.ts","sourceRoot":"","sources":["../../src/gateway/GatewayPlanner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AAIvC,OAAO,KAAK,EACV,6BAA6B,EAC7B,0BAA0B,EAC1B,oBAAoB,EACpB,4BAA4B,EAE7B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AAGpC,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,iBAAiB,CAAC,EAAE,wBAAwB,CAAC;IAC7C,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,kCAAkC,CAAC,CAAC;CAChF;AAED,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,EAAE,wBAAwB,CAAC;IAC5C,UAAU,EAAE,6BAA6B,CAAC;IAC1C,OAAO,EAAE,0BAA0B,CAAC;IACpC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,wBAAwB,EAAE,MAAM,CAAC;IACjC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,4BAA4B,EAAE,CAAC;gBAErC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,4BAA4B,EAAE;CAMnF;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBnC,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ChC,CAAC;AA2IX,eAAO,MAAM,oCAAoC,GAC/C,OAAO,mBAAmB,KACzB,eAAe,EAyBjB,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC5C,OAAO,mBAAmB,EAC1B,YAAY,6BAA6B,KACxC,eAAe,EAsCjB,CAAC;AAuDF,qBAAa,oBAAoB;IAI7B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAGxB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,2BAAgC;IAKtD,QAAQ,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC;QAClD,UAAU,EAAE,6BAA6B,CAAC;QAC1C,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IAiBI,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,2BAA2B,CAAC;YA2C9D,iBAAiB;CA8ChC;AAED,eAAO,MAAM,0BAA0B,GACrC,UAAU,QAAQ,EAClB,UAAU,2BAA2B,KACpC,oBAAmE,CAAC"}