sdl-mcp 0.11.13 → 0.12.0

package/dist/mcp/context-response-projection.js

@@ -4,30 +4,32 @@
  */
 /** Fields kept in the compact broad response before final model-content projection.
  *  Shared with context-engine.ts for pre-truncation compaction. */
-export const BROAD_VISIBLE_FIELDS = new Set([
-    "taskId",
+const BROAD_MODEL_VISIBLE_FIELDS = new Set([
     "taskType",
     "success",
     "summary",
     "answer",
     "finalEvidence",
     "nextBestAction",
-    "retrievalEvidence",
-    "diagnostics",
     "error",
     "truncation",
+]);
+export const BROAD_VISIBLE_FIELDS = new Set([
+    ...BROAD_MODEL_VISIBLE_FIELDS,
     "etag",
-    "_displayFooter",
+    "diagnostics",
+    "retrievalEvidence",
 ]);
 /** Tool names eligible for context-specific compaction. */
 const CONTEXT_TOOLS = new Set(["sdl.context"]);
+const HIDDEN_ETAG_MODEL_FIELDS = new Set(["etag", "etagCache", "sliceEtag"]);
 const ALWAYS_INTERNAL_MODEL_FIELDS = new Set([
     "_displayFooter",
+    "_packedPayload",
     "_packedStats",
     "_rawContext",
     "_tokenUsage",
     "actionsTaken",
-    "backupPath",
     "indexUpdate",
     "metrics",
     "packedStats",
@@ -36,12 +38,160 @@ const ALWAYS_INTERNAL_MODEL_FIELDS = new Set([
     "serverDiagnostics",
     "taskId",
     "timings",
+    "tokenEstimate",
     "totalTokens",
-    "trace",
+    "etagCache",
+    "sliceEtag",
+]);
+const NO_OP_FALSE_FIELDS = new Set([
+    "truncated",
+    "truncation",
+    "blastRadiusTruncated",
+]);
+const NO_OP_NULL_FIELDS = new Set([
+    "signal",
 ]);
+const NO_OP_EMPTY_ARRAY_FIELDS = new Set([
+    "warnings",
+    "quotingWarnings",
+    "serverDriftWarnings",
+    "filesSkipped",
+    "filesSkippedByReason",
+    "staleSymbols",
+    "missedIdentifiers",
+]);
+const COMPACT_FAILURE_TRACE_FIELDS = new Set([
+    "stepIndex",
+    "fn",
+    "action",
+    "kind",
+    "status",
+    "message",
+    "fallbackTools",
+]);
+const COMPACT_DEBUG_MODEL_FIELDS = new Set([
+    "aggregateStats",
+    "amplifiers",
+    "astFingerprint",
+    "bytes",
+    "bytesWritten",
+    "callResolution",
+    "clustersHint",
+    "confidenceDistribution",
+    "created",
+    "deduplicated",
+    "detailLevel",
+    "detailLevelMetadata",
+    "diagnostics",
+    "entryPoints",
+    "expiresAt",
+    "hotspots",
+    "lease",
+    "ledgerVersion",
+    "linesWritten",
+    "matchCount",
+    "matchedLineNumbers",
+    "mtimeMs",
+    "originalLines",
+    "pprBoosts",
+    "processes",
+    "relevance",
+    "returnedLines",
+    "searchedStreams",
+    "sessionDelta",
+    "sha256",
+    "shortId",
+    "sliceEtag",
+    "stderrPreview",
+    "stdinBytes",
+    "stdinSha256",
+    "stdoutPreview",
+    "symbolsRecorded",
+    "symbolIndex",
+    "symptomType",
+    "totalBytes",
+    "totalLines",
+    "truncationWarning",
+    "versionId",
+    "visibility",
+    "whyApproved",
+]);
+const REPO_ID_VISIBLE_TOOLS = new Set([
+    "repo.status",
+    "sdl.repo.status",
+    "repo.overview",
+    "sdl.repo.overview",
+    "delta.get",
+    "sdl.delta.get",
+    "sdl.workflow",
+    "workflow",
+]);
+const PRECONDITION_MODEL_FIELDS = new Set([
+    "astFingerprint",
+    "mtimeMs",
+    "preconditionSnapshot",
+    "sha256",
+]);
+const PRECONDITION_VISIBLE_TOOLS = new Set([
+    "search.edit",
+    "sdl.search.edit",
+    "symbol.edit",
+    "sdl.symbol.edit",
+    "symbol.getCard",
+    "sdl.symbol.getCard",
+]);
+const FILE_PRECONDITION_OPS = new Set([
+    "searchEditPreview",
+    "searchEditApply",
+    "symbolEditPreview",
+    "symbolEditApply",
+    "symbolEditApplyNow",
+]);
+const WORKFLOW_CHILD_TOOL_NAMES = {
+    actionSearch: "action.search",
+    codeHotPath: "code.getHotPath",
+    codeNeedWindow: "code.needWindow",
+    codeSkeleton: "code.getSkeleton",
+    deltaGet: "delta.get",
+    file: "sdl.file",
+    sdlFile: "sdl.file",
+    fileRead: "file.read",
+    fileWrite: "file.write",
+    indexRefresh: "index.refresh",
+    policyGet: "policy.get",
+    policySet: "policy.set",
+    prRiskAnalyze: "pr.risk.analyze",
+    repoOverview: "repo.overview",
+    repoStatus: "repo.status",
+    runtimeExecute: "runtime.execute",
+    runtimeQueryOutput: "runtime.queryOutput",
+    searchEdit: "search.edit",
+    sliceBuild: "slice.build",
+    sliceRefresh: "slice.refresh",
+    symbolEdit: "symbol.edit",
+    symbolGetCard: "symbol.getCard",
+    symbolGetCards: "symbol.getCards",
+    symbolSearch: "symbol.search",
+    usageStats: "usage.stats",
+};
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function stripEtagFieldsForModel(value) {
+    if (Array.isArray(value)) {
+        return value.map(stripEtagFieldsForModel);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const projected = {};
+    for (const [key, itemValue] of Object.entries(value)) {
+        if (!HIDDEN_ETAG_MODEL_FIELDS.has(key)) {
+            projected[key] = stripEtagFieldsForModel(itemValue);
+        }
+    }
+    return projected;
+}
 function copyIfPresent(source, target, key) {
     if (key in source) {
         target[key] = source[key];
@@ -64,27 +214,121 @@ function projectEvidenceForModel(value) {
         return projected;
     });
 }
+function normalizedDetail(value) {
+    return value === "full" || value === "standard" ? value : "compact";
+}
 function modelOptionsFromArgs(args) {
     const options = isRecord(args.options) ? args.options : {};
     return {
-        includeDiagnostics: args.includeDiagnostics === true,
+        detail: normalizedDetail(args.detail ?? options.detail),
+        includeDiagnostics: args.includeDiagnostics === true
+            || options.includeDiagnostics === true,
         includeRetrievalEvidence: args.includeRetrievalEvidence === true
             || options.includeRetrievalEvidence === true,
+        includeTelemetry: args.includeTelemetry === true
+            || options.includeTelemetry === true,
+        includeTrace: args.trace !== undefined,
+        includeProcesses: args.includeProcesses === true,
+        includeResolutionMetadata: args.includeResolutionMetadata === true,
+        fileOp: typeof args.op === "string" ? args.op : undefined,
     };
 }
+function isFullDetail(options) {
+    return options.detail === "full";
+}
+function isNoOpTruncationObject(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.truncated === true
+        || value.stdoutTruncated === true
+        || value.stderrTruncated === true) {
+        return false;
+    }
+    return Object.keys(value).every((key) => key === "truncated"
+        || key === "stdoutTruncated"
+        || key === "stderrTruncated"
+        || key === "totalStdoutBytes"
+        || key === "totalStderrBytes");
+}
+function shouldDropNoOpField(key, value) {
+    if (value === false && NO_OP_FALSE_FIELDS.has(key)) {
+        return true;
+    }
+    if (key === "truncation" && isNoOpTruncationObject(value)) {
+        return true;
+    }
+    if (value === null && NO_OP_NULL_FIELDS.has(key)) {
+        return true;
+    }
+    if (Array.isArray(value)
+        && value.length === 0
+        && NO_OP_EMPTY_ARRAY_FIELDS.has(key)) {
+        return true;
+    }
+    if (key === "rollback" && isRecord(value)) {
+        return Object.keys(value).length === 0 || value.triggered === false;
+    }
+    return false;
+}
+function keepsPreconditionField(toolName, options) {
+    return PRECONDITION_VISIBLE_TOOLS.has(toolName)
+        || ((toolName === "sdl.file" || toolName === "file")
+            && typeof options.fileOp === "string"
+            && FILE_PRECONDITION_OPS.has(options.fileOp));
+}
 function shouldKeepModelField(toolName, key, options) {
-    if (toolName === "sdl.workflow" && key === "trace") {
+    if (isFullDetail(options)) {
+        return true;
+    }
+    if (key === "trace") {
+        return toolName === "sdl.workflow" && options.includeTrace;
+    }
+    if (PRECONDITION_MODEL_FIELDS.has(key) && keepsPreconditionField(toolName, options)) {
         return true;
     }
     if (ALWAYS_INTERNAL_MODEL_FIELDS.has(key)) {
         return false;
     }
+    if (key === "repoId") {
+        return REPO_ID_VISIBLE_TOOLS.has(toolName);
+    }
+    if (key === "processes") {
+        return options.includeProcesses;
+    }
+    if (key === "callResolution") {
+        return options.includeResolutionMetadata;
+    }
+    if (COMPACT_DEBUG_MODEL_FIELDS.has(key)) {
+        return false;
+    }
+    if (toolName === "slice.build" && key === "budget") {
+        return false;
+    }
+    if ((toolName === "symbol.search" || toolName === "sdl.symbol.search") && key === "symbols") {
+        return false;
+    }
     if (key === "diagnostics") {
         return options.includeDiagnostics;
     }
     if (key === "retrievalEvidence") {
         return options.includeRetrievalEvidence;
     }
+    if (key === "estimatedTokens"
+        || key === "originalLines"
+        || key === "matchedLineNumbers"
+        || key === "generatedAt"
+        || key === "tokenMetrics") {
+        return false;
+    }
+    if (options.detail === "compact"
+        && !options.includeTelemetry
+        && (key === "prefetchStats"
+            || key === "strategyMetrics"
+            || key === "topStrategies"
+            || key === "healthComponents")) {
+        return false;
+    }
     return true;
 }
 function projectGenericValueForModel(toolName, value, options) {
@@ -96,6 +340,12 @@ function projectGenericValueForModel(toolName, value, options) {
     }
     const projected = {};
     for (const [key, itemValue] of Object.entries(value)) {
+        if (HIDDEN_ETAG_MODEL_FIELDS.has(key)) {
+            continue;
+        }
+        if (shouldDropNoOpField(key, itemValue)) {
+            continue;
+        }
         if (key === "diagnostics" && options.includeDiagnostics) {
             projected[key] = itemValue;
             continue;
@@ -106,7 +356,7 @@ function projectGenericValueForModel(toolName, value, options) {
         }
         if (key === "policyDecision") {
             const decision = isRecord(itemValue) ? itemValue : {};
-            if (Array.isArray(decision.deniedReasons)) {
+            if (Array.isArray(decision.deniedReasons) && decision.deniedReasons.length > 0) {
                 projected.policyDecision = { deniedReasons: decision.deniedReasons };
             }
             continue;
@@ -114,7 +364,11 @@ function projectGenericValueForModel(toolName, value, options) {
         if (!shouldKeepModelField(toolName, key, options)) {
             continue;
         }
-        projected[key] = projectGenericValueForModel(toolName, itemValue, options);
+        const projectedValue = projectGenericValueForModel(toolName, itemValue, options);
+        if (isRecord(projectedValue) && Object.keys(projectedValue).length === 0) {
+            continue;
+        }
+        projected[key] = projectedValue;
     }
     return projected;
 }
@@ -131,8 +385,9 @@ function projectContextResultForModel(result, options) {
     }
     copyIfPresent(result, projected, "nextBestAction");
     copyIfPresent(result, projected, "error");
-    copyIfPresent(result, projected, "truncation");
-    copyIfPresent(result, projected, "etag");
+    if (result.truncation !== false) {
+        copyIfPresent(result, projected, "truncation");
+    }
     if (options.includeRetrievalEvidence) {
         copyIfPresent(result, projected, "retrievalEvidence");
     }
@@ -141,57 +396,302 @@ function projectContextResultForModel(result, options) {
     }
     return projected;
 }
+function projectCompactFailureTrace(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const projected = {};
+    for (const [key, itemValue] of Object.entries(value)) {
+        if (COMPACT_FAILURE_TRACE_FIELDS.has(key)) {
+            projected[key] = itemValue;
+        }
+    }
+    return projected;
+}
+function workflowStepArgsAt(workflowArgs, stepIndex) {
+    const steps = workflowArgs.steps;
+    if (!Array.isArray(steps)) {
+        return undefined;
+    }
+    const step = steps[stepIndex];
+    return isRecord(step) ? step.args : undefined;
+}
+function inferWorkflowFileOp(childToolName, result, args) {
+    if (isRecord(args) && typeof args.op === "string") {
+        return args.op;
+    }
+    if (childToolName === "sdl.file" && isRecord(result) && "preconditionSnapshot" in result) {
+        return "searchEditPreview";
+    }
+    return undefined;
+}
+function projectWorkflowStepResultForModel(fn, result, options, args) {
+    const childToolName = typeof fn === "string"
+        ? WORKFLOW_CHILD_TOOL_NAMES[fn] ?? "sdl.workflow"
+        : "sdl.workflow";
+    const childArgOptions = isRecord(args) ? modelOptionsFromArgs(args) : undefined;
+    const fileOp = inferWorkflowFileOp(childToolName, result, args);
+    if (isFullDetail(options)) {
+        return stripEtagFieldsForModel(result);
+    }
+    const childOptions = {
+        ...options,
+        detail: "compact",
+        includeDiagnostics: false,
+        includeRetrievalEvidence: false,
+        includeTelemetry: false,
+        includeTrace: false,
+        ...(childArgOptions ?? {}),
+        fileOp: fileOp ?? childArgOptions?.fileOp ?? options.fileOp,
+    };
+    if (isFullDetail(childOptions)) {
+        return stripEtagFieldsForModel(result);
+    }
+    if (childToolName === "repo.status") {
+        if (childOptions.detail === "compact" && !childOptions.includeTelemetry) {
+            return isRecord(result) ? projectRepoStatusForModel(result, childOptions) : result;
+        }
+        return projectGenericValueForModel(childToolName, result, childOptions);
+    }
+    if (childToolName === "action.search" && childOptions.detail === "compact") {
+        return isRecord(result) ? projectActionSearchForModel(result) : result;
+    }
+    if (childToolName === "usage.stats") {
+        return isRecord(result) ? projectUsageStatsForModel(result) : result;
+    }
+    return projectGenericValueForModel(childToolName, result, childOptions);
+}
+function projectWorkflowResultForModel(result, options, workflowArgs = {}) {
+    const includeWorkflowTelemetry = options.includeTrace
+        || options.includeDiagnostics
+        || options.includeTelemetry
+        || isFullDetail(options);
+    const projected = {};
+    const rawResults = Array.isArray(result.results) ? result.results : [];
+    projected.results = rawResults.map((item, index) => {
+        if (!isRecord(item)) {
+            return item;
+        }
+        const status = typeof item.status === "string" ? item.status : "ok";
+        const stepIndex = typeof item.stepIndex === "number" ? item.stepIndex : index;
+        const stepArgs = workflowStepArgsAt(workflowArgs, stepIndex) ?? item.args;
+        if (status === "ok") {
+            const successStep = { fn: item.fn };
+            if (includeWorkflowTelemetry) {
+                copyIfPresent(item, successStep, "stepIndex");
+                copyIfPresent(item, successStep, "tokens");
+                copyIfPresent(item, successStep, "durationMs");
+                copyIfPresent(item, successStep, "status");
+            }
+            if ("result" in item) {
+                successStep.result = projectWorkflowStepResultForModel(item.fn, item.result, options, stepArgs);
+            }
+            if (item.truncatedResponse) {
+                successStep.truncatedResponse = item.truncatedResponse;
+            }
+            return successStep;
+        }
+        const failureStep = { fn: item.fn, status };
+        copyIfPresent(item, failureStep, "error");
+        copyIfPresent(item, failureStep, "fallbackTools");
+        copyIfPresent(item, failureStep, "blockedByStep");
+        copyIfPresent(item, failureStep, "blockedByFn");
+        copyIfPresent(item, failureStep, "blockedByError");
+        if ("failureTrace" in item) {
+            failureStep.failureTrace = projectCompactFailureTrace(item.failureTrace);
+        }
+        if ("result" in item && item.result !== null && item.result !== undefined) {
+            failureStep.result = projectWorkflowStepResultForModel(item.fn, item.result, options, stepArgs);
+        }
+        return failureStep;
+    });
+    if (includeWorkflowTelemetry) {
+        copyIfPresent(result, projected, "durationMs");
+        copyIfPresent(result, projected, "totalTokens");
+    }
+    if (result.truncated === true) {
+        projected.truncated = true;
+    }
+    if (options.includeTrace) {
+        copyIfPresent(result, projected, "trace");
+    }
+    if (options.includeDiagnostics) {
+        copyIfPresent(result, projected, "diagnostics");
+    }
+    return projected;
+}
+function projectUsageStatsForModel(result) {
+    const projected = {};
+    copyIfPresent(result, projected, "formattedSummary");
+    return projected;
+}
+function projectDerivedStateForModel(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const projected = {};
+    copyIfPresent(value, projected, "stale");
+    for (const key of [
+        "clustersDirty",
+        "processesDirty",
+        "algorithmsDirty",
+        "summariesDirty",
+        "embeddingsDirty",
+    ]) {
+        if (value[key] === true) {
+            projected[key] = true;
+        }
+    }
+    copyIfPresent(value, projected, "lastError");
+    copyIfPresent(value, projected, "nextBestAction");
+    return projected;
+}
+function watcherNeedsAttention(value) {
+    return value.running === false
+        || value.stale === true
+        || (typeof value.errors === "number" && value.errors > 0)
+        || Boolean(value.fallbackReason);
+}
+function projectWatcherHealthForModel(value) {
+    if (!isRecord(value) || !watcherNeedsAttention(value)) {
+        return undefined;
+    }
+    const projected = {};
+    for (const key of [
+        "enabled",
+        "running",
+        "provider",
+        "fallbackReason",
+        "errors",
+        "queueDepth",
+        "stale",
+    ]) {
+        copyIfPresent(value, projected, key);
+    }
+    return projected;
+}
+function projectRepoStatusForModel(result, options) {
+    const projected = {};
+    for (const key of [
+        "repoId",
+        "rootPath",
+        "latestVersionId",
+        "filesIndexed",
+        "symbolsIndexed",
+        "lastIndexedAt",
+    ]) {
+        copyIfPresent(result, projected, key);
+    }
+    if (result.healthAvailable === true || result.healthScore !== undefined) {
+        copyIfPresent(result, projected, "healthAvailable");
+        copyIfPresent(result, projected, "healthScore");
+    }
+    if ("derivedState" in result) {
+        projected.derivedState = projectDerivedStateForModel(result.derivedState);
+    }
+    const compactWatcher = projectWatcherHealthForModel(result.watcherHealth);
+    if (compactWatcher !== undefined) {
+        projected.watcherHealth = compactWatcher;
+    }
+    copyIfPresent(result, projected, "nextBestAction");
+    if (options.includeDiagnostics) {
+        copyIfPresent(result, projected, "diagnostics");
+    }
+    if (options.includeRetrievalEvidence) {
+        copyIfPresent(result, projected, "retrievalEvidence");
+    }
+    return projected;
+}
+function compactSchemaSummary(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value.map((field) => {
+        if (!isRecord(field)) {
+            return field;
+        }
+        const projected = {};
+        for (const key of ["name", "type", "required", "default", "enumValues", "subFields"]) {
+            if (key === "subFields") {
+                if ("subFields" in field) {
+                    projected.subFields = compactSchemaSummary(field.subFields);
+                }
+            }
+            else {
+                copyIfPresent(field, projected, key);
+            }
+        }
+        return projected;
+    });
+}
+function projectActionSearchForModel(result) {
+    const projected = {};
+    if (Array.isArray(result.actions)) {
+        projected.actions = result.actions.map((action) => {
+            if (!isRecord(action)) {
+                return action;
+            }
+            const compact = {};
+            copyIfPresent(action, compact, "action");
+            copyIfPresent(action, compact, "fn");
+            copyIfPresent(action, compact, "requiredParams");
+            copyIfPresent(action, compact, "disabled");
+            copyIfPresent(action, compact, "disabledReason");
+            if (isRecord(action.schemaSummary) && Array.isArray(action.schemaSummary.fields)) {
+                compact.schemaSummary = {
+                    fields: compactSchemaSummary(action.schemaSummary.fields),
+                };
+            }
+            return compact;
+        });
+    }
+    copyIfPresent(result, projected, "summary");
+    copyIfPresent(result, projected, "total");
+    copyIfPresent(result, projected, "hasMore");
+    copyIfPresent(result, projected, "nextCursor");
+    copyIfPresent(result, projected, "disabledHint");
+    copyIfPresent(result, projected, "schemaHint");
+    return projected;
+}
 /**
  * Returns true when the result looks like a broad context response that
  * should be compacted.
  */
 export function isBroadContextResult(toolName, result) {
-    if (!CONTEXT_TOOLS.has(toolName))
+    if (!CONTEXT_TOOLS.has(toolName)) {
         return false;
-    if (!isRecord(result))
+    }
+    if (!isRecord(result)) {
         return false;
+    }
     const r = result;
-    // Broad results have actionsTaken + path + metrics (precise mode strips some of these
-    // but still has actionsTaken). The key differentiator: broad mode has `answer` field.
-    // Also check it's not an error result (which should pass through unchanged).
     return ("taskId" in r &&
         "actionsTaken" in r &&
         "answer" in r &&
         r.success !== undefined);
 }
-/**
- * Project a broad context result to its compact internal response form.
- * Returns the original result unchanged if it doesn't qualify.
- */
 export function projectBroadContextResult(toolName, result) {
-    if (!isBroadContextResult(toolName, result))
+    if (!isBroadContextResult(toolName, result)) {
         return result;
+    }
     const r = result;
     const projected = {};
     for (const key of Object.keys(r)) {
-        if (BROAD_VISIBLE_FIELDS.has(key)) {
+        if (BROAD_MODEL_VISIBLE_FIELDS.has(key)) {
             projected[key] = r[key];
         }
     }
     return projected;
 }
-/**
- * Project tool responses before token accounting while keeping the internal raw
- * baseline hint that `computeTokenUsage()` needs.
- */
 export function projectContextResultForUsageAccounting(toolName, result, args = {}) {
     const projected = projectToolResultForModelContent(toolName, result, args);
-    if (!isRecord(projected) || projected === result) {
+    if (!isRecord(projected)) {
         return result;
     }
-    const accountingResult = projected;
     if ("_rawContext" in result) {
-        return {
-            ...accountingResult,
-            _rawContext: result._rawContext,
-        };
+        return { ...projected, _rawContext: result._rawContext };
     }
-    return accountingResult;
+    return projected;
 }
 /**
  * Project the payload serialized into MCP text content for the model/user.
@@ -203,9 +703,28 @@ export function projectToolResultForModelContent(toolName, result, args = {}) {
         return result;
     }
     const options = modelOptionsFromArgs(args);
+    if (toolName === "sdl.workflow" || toolName === "workflow") {
+        return projectWorkflowResultForModel(result, options, args);
+    }
+    if (isFullDetail(options)) {
+        return result;
+    }
     if (CONTEXT_TOOLS.has(toolName) && ("answer" in result || "finalEvidence" in result)) {
         return projectContextResultForModel(result, options);
     }
+    if (toolName === "usage.stats" || toolName === "sdl.usage.stats") {
+        return projectUsageStatsForModel(result);
+    }
+    if (toolName === "repo.status" || toolName === "sdl.repo.status") {
+        if (options.detail === "compact" && !options.includeTelemetry) {
+            return projectRepoStatusForModel(result, options);
+        }
+    }
+    if (toolName === "action.search" || toolName === "sdl.action.search") {
+        if (options.detail === "compact") {
+            return projectActionSearchForModel(result);
+        }
+    }
     return projectGenericValueForModel(toolName, result, options);
 }
 //# sourceMappingURL=context-response-projection.js.map