@deftai/directive-core 0.87.0 → 0.89.0

package/dist/escalation/store.js

@@ -0,0 +1,172 @@
+/**
+ * Disk store for typed escalations under `.deft/escalations/` (#518).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
+import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { escalationPath, escalationsDir } from "./paths.js";
+import { DEFAULT_SLA_HOURS, ESCALATION_DECISIONS, ESCALATION_SCHEMA_VERSION, ESCALATION_STATUSES, ESCALATION_TYPES, isEscalationType, } from "./types.js";
+export function utcIso(now) {
+    const dt = now ?? new Date();
+    return dt.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * Contained atomic JSON write for escalations (#2980 / Greptile P1).
+ * Containment root is projectRoot (not dirname(target)) so parent-symlink escape fails closed.
+ * Unique random temp names avoid PID-reuse collisions; rename is the atomic publish step.
+ */
+function writeJsonContained(projectRoot, targetPath, payload) {
+    const root = resolve(projectRoot);
+    const abs = resolve(targetPath);
+    // Refuse leaf/parent symlinks on the final path before temp+rename publish.
+    assertWriteTargetSafe(root, abs);
+    const dir = dirname(abs);
+    const tmpBase = `.${basename(abs)}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    const tmp = join(dir, tmpBase);
+    try {
+        containedWrite({
+            root,
+            target: tmp,
+            data: `${JSON.stringify(payload, null, 2)}\n`,
+            mode: "create",
+        });
+        renameSync(tmp, abs);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+}
+function readString(rec, key) {
+    const v = rec[key];
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : null;
+}
+function readStringArray(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((x) => typeof x === "string" && x.trim().length > 0);
+}
+function readNumber(rec, key) {
+    const v = rec[key];
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function parseResolution(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    const rec = record(raw);
+    if (rec === null)
+        return null;
+    const decision = readString(rec, "decision");
+    const resolvedAt = readString(rec, "resolvedAt") ?? readString(rec, "resolved_at") ?? utcIso();
+    const resolvedBy = readString(rec, "resolvedBy") ?? readString(rec, "resolved_by") ?? "operator";
+    if (decision === null || !ESCALATION_DECISIONS.includes(decision)) {
+        return null;
+    }
+    return {
+        decision: decision,
+        resolvedAt,
+        resolvedBy,
+        note: readString(rec, "note"),
+        answer: readString(rec, "answer"),
+    };
+}
+/**
+ * Parse an escalation JSON object.
+ * Returns null when type/status/required fields are invalid (tests reject invalid types).
+ */
+export function parseEscalation(raw) {
+    const rec = record(raw);
+    if (rec === null)
+        return null;
+    const id = readString(rec, "id");
+    const agentId = readString(rec, "agentId") ?? readString(rec, "agent_id");
+    const typeRaw = readString(rec, "type");
+    const title = readString(rec, "title");
+    if (id === null || agentId === null || typeRaw === null || title === null)
+        return null;
+    if (!isEscalationType(typeRaw))
+        return null;
+    const statusRaw = (readString(rec, "status") ?? "open").toLowerCase();
+    if (!ESCALATION_STATUSES.includes(statusRaw))
+        return null;
+    const body = typeof rec.body === "string" ? rec.body : "";
+    const contextRefs = readStringArray(rec.contextRefs ?? rec.context_refs);
+    const createdAt = readString(rec, "createdAt") ?? readString(rec, "created_at") ?? utcIso();
+    const sla = readNumber(rec, "slaHours") ??
+        readNumber(rec, "sla_hours") ??
+        DEFAULT_SLA_HOURS[typeRaw];
+    const dangerous = rec.dangerous === true;
+    const resolution = parseResolution(rec.resolution);
+    return {
+        schemaVersion: ESCALATION_SCHEMA_VERSION,
+        id,
+        agentId,
+        type: typeRaw,
+        title,
+        body,
+        contextRefs,
+        createdAt,
+        slaHours: sla > 0 ? sla : DEFAULT_SLA_HOURS[typeRaw],
+        status: statusRaw,
+        dangerous,
+        resolution,
+    };
+}
+/** Validate type string alone (unit tests + CLI). */
+export function validateEscalationType(type) {
+    const normalized = type.trim().toLowerCase();
+    if (!isEscalationType(normalized)) {
+        throw new Error(`invalid escalation type '${type}'; expected one of: ${ESCALATION_TYPES.join(", ")}`);
+    }
+    return normalized;
+}
+export function saveEscalation(projectRoot, event) {
+    writeJsonContained(projectRoot, escalationPath(projectRoot, event.id), event);
+}
+export function loadEscalation(projectRoot, escalationId) {
+    const path = escalationPath(projectRoot, escalationId);
+    if (!existsSync(path))
+        return null;
+    try {
+        return parseEscalation(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function listEscalations(projectRoot) {
+    const dir = escalationsDir(projectRoot);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const event = parseEscalation(JSON.parse(readFileSync(join(dir, name), "utf8")));
+            if (event !== null)
+                out.push(event);
+        }
+        catch {
+            // skip corrupt files
+        }
+    }
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out;
+}
+export function listOpenEscalations(projectRoot) {
+    return listEscalations(projectRoot).filter((e) => e.status === "open");
+}
+//# sourceMappingURL=store.js.map

package/dist/escalation/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Typed escalation events + local queue store (#518 slim / #2948 Wave 5).
+ *
+ * Full priority-inbox web UI and metrics remain residual — this module is the
+ * versioned schema + `.deft/escalations/` file queue for CLI batching.
+ */
+/** Fixed vocabulary of escalation reasons (#518). */
+export declare const ESCALATION_TYPES: readonly ["cmd_approval", "design_decision", "approval", "resource", "external", "question"];
+export type EscalationType = (typeof ESCALATION_TYPES)[number];
+/**
+ * Types eligible for `escalation:batch-approve`.
+ * design_decision / approval / resource / external stay individual resolve.
+ */
+export declare const BATCH_APPROVABLE_TYPES: readonly ["cmd_approval", "question"];
+export type BatchApprovableType = (typeof BATCH_APPROVABLE_TYPES)[number];
+export declare const ESCALATION_STATUSES: readonly ["open", "resolved"];
+export type EscalationStatus = (typeof ESCALATION_STATUSES)[number];
+export declare const ESCALATION_DECISIONS: readonly ["approved", "denied", "answered", "dismissed"];
+export type EscalationDecision = (typeof ESCALATION_DECISIONS)[number];
+/** Default SLA hours per type (issue #518 table). */
+export declare const DEFAULT_SLA_HOURS: Readonly<Record<EscalationType, number>>;
+export interface EscalationResolution {
+    readonly decision: EscalationDecision;
+    readonly resolvedAt: string;
+    readonly resolvedBy: string;
+    readonly note: string | null;
+    /** Free-text answer for `question` type (optional for other types). */
+    readonly answer: string | null;
+}
+/**
+ * Versioned escalation event (YAML shape from #518, camelCase on disk).
+ *
+ * ```json
+ * {
+ *   "schemaVersion": 1,
+ *   "id": "esc-…",
+ *   "agentId": "agent-b",
+ *   "type": "design_decision",
+ *   "title": "…",
+ *   "body": "…",
+ *   "contextRefs": ["xbrief/…", "#496"],
+ *   "createdAt": "2026-07-30T10:00:00Z",
+ *   "slaHours": 4,
+ *   "status": "open",
+ *   "dangerous": false,
+ *   "resolution": null
+ * }
+ * ```
+ */
+export interface EscalationEvent {
+    readonly schemaVersion: 1;
+    readonly id: string;
+    readonly agentId: string;
+    readonly type: EscalationType;
+    readonly title: string;
+    readonly body: string;
+    readonly contextRefs: readonly string[];
+    readonly createdAt: string;
+    readonly slaHours: number;
+    readonly status: EscalationStatus;
+    /**
+     * When true, batch-approve skips this item unless `--include-dangerous`.
+     * Use for shell write-scope cmd_approval, PR merges, and similar.
+     */
+    readonly dangerous: boolean;
+    readonly resolution: EscalationResolution | null;
+}
+export declare const ESCALATION_SCHEMA_VERSION: 1;
+export declare const ESCALATION_DIR = ".deft/escalations";
+export declare function isEscalationType(value: string): value is EscalationType;
+export declare function isBatchApprovableType(type: EscalationType): type is BatchApprovableType;
+export declare function isEscalationDecision(value: string): value is EscalationDecision;
+//# sourceMappingURL=types.d.ts.map

package/dist/escalation/types.js

@@ -0,0 +1,43 @@
+/**
+ * Typed escalation events + local queue store (#518 slim / #2948 Wave 5).
+ *
+ * Full priority-inbox web UI and metrics remain residual — this module is the
+ * versioned schema + `.deft/escalations/` file queue for CLI batching.
+ */
+/** Fixed vocabulary of escalation reasons (#518). */
+export const ESCALATION_TYPES = [
+    "cmd_approval",
+    "design_decision",
+    "approval",
+    "resource",
+    "external",
+    "question",
+];
+/**
+ * Types eligible for `escalation:batch-approve`.
+ * design_decision / approval / resource / external stay individual resolve.
+ */
+export const BATCH_APPROVABLE_TYPES = ["cmd_approval", "question"];
+export const ESCALATION_STATUSES = ["open", "resolved"];
+export const ESCALATION_DECISIONS = ["approved", "denied", "answered", "dismissed"];
+/** Default SLA hours per type (issue #518 table). */
+export const DEFAULT_SLA_HOURS = {
+    cmd_approval: 1,
+    design_decision: 4,
+    approval: 4,
+    resource: 4,
+    external: 72,
+    question: 24,
+};
+export const ESCALATION_SCHEMA_VERSION = 1;
+export const ESCALATION_DIR = ".deft/escalations";
+export function isEscalationType(value) {
+    return ESCALATION_TYPES.includes(value);
+}
+export function isBatchApprovableType(type) {
+    return BATCH_APPROVABLE_TYPES.includes(type);
+}
+export function isEscalationDecision(value) {
+    return ESCALATION_DECISIONS.includes(value);
+}
+//# sourceMappingURL=types.js.map

package/dist/eval/crud-telemetry.js

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { helpedMetricsHistoryPath } from "../metrics/resolve-metrics-home.js";
 import { scanVbrief } from "../vbrief-validate/conformance.js";
 import { validateVbriefSchema } from "../vbrief-validate/schema.js";
@@ -83,8 +84,19 @@ function assessDocument(path, parsed) {
 function sanitizeInlineMessage(message) {
     return message.replace(/\r?\n/g, " ");
 }
-function ensureParentDir(path) {
-    mkdirSync(dirname(path), { recursive: true });
+/**
+ * Contained replace under the target's parent directory (#2980 wave C).
+ * Metrics/CRUD sinks may live outside the project tree (platform metrics home).
+ */
+function containedReplaceAt(path, content) {
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: content,
+        mode: "replace",
+    });
 }
 /** Absolute path to the versioned CRUD metrics ledger (#1703 Tier 1 / #2545). */
 export function crudMetricsHistoryPath(projectRoot) {
@@ -99,9 +111,17 @@ export function persistCrudMetrics(projectRoot, metrics) {
     if (path === null) {
         return;
     }
-    mkdirSync(dirname(path), { recursive: true });
+    // #2980 wave C: product write sink routes through containedWrite.
+    // Metrics home is often outside the project tree (#2545) — contain under ledger parent.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
     for (const metric of metrics) {
-        appendFileSync(path, `${JSON.stringify(metric)}\n`, "utf8");
+        containedWrite({
+            root: resolve(dir),
+            target: basename(path),
+            data: `${JSON.stringify(metric)}\n`,
+            mode: "append",
+        });
     }
 }
 /**
@@ -155,8 +175,8 @@ export class InstrumentedVbriefCrud {
         if (!assessment.schemaValid) {
             return { ok: false, error: assessment.schemaErrors.join("; ") };
         }
-        ensureParentDir(path);
-        writeFileSync(path, content, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedReplaceAt(path, content);
         return { ok: true };
     }
     read(path) {
@@ -244,8 +264,8 @@ export class InstrumentedVbriefCrud {
         if (!assessment.schemaValid && !options.trustedWrite) {
             return { ok: false, error: assessment.schemaErrors.join("; ") };
         }
-        ensureParentDir(path);
-        writeFileSync(path, content, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedReplaceAt(path, content);
         return { ok: true };
     }
     /** Record update metrics without persisting (caller owns validated atomic write). */

package/dist/eval/health.js

@@ -1,9 +1,9 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { agentsRefreshPlan } from "../doctor/agents-md.js";
 import { evaluate as evaluateEncoding } from "../encoding/evaluate.js";
 import { readCorePackageVersion } from "../engine-version.js";
-import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { healthMetricsHistoryPath } from "../metrics/resolve-metrics-home.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
@@ -163,14 +163,29 @@ export function persistHealthRun(projectRoot, report) {
     if (path === null) {
         return;
     }
+    // #2980 wave C: product write sink routes through containedWrite.
+    // Project-local metrics: contain under projectRoot. Platform/env home: under ledger parent.
     const projectAbs = resolve(projectRoot);
     const targetAbs = resolve(path);
     const rel = relative(projectAbs, targetAbs);
-    if (rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel)) {
-        assertWriteTargetSafe(projectRoot, path);
+    const nested = rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    if (nested) {
+        containedWrite({
+            root: projectAbs,
+            target: targetAbs,
+            data: `${JSON.stringify(report)}\n`,
+            mode: "append",
+        });
+        return;
     }
-    mkdirSync(dirname(path), { recursive: true });
-    appendFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
+    const parent = dirname(targetAbs);
+    mkdirSync(parent, { recursive: true });
+    containedWrite({
+        root: resolve(parent),
+        target: basename(targetAbs),
+        data: `${JSON.stringify(report)}\n`,
+        mode: "append",
+    });
 }
 function collectStaticGates(projectRoot, frameworkSource) {
     const gates = [

package/dist/eval/readback.js

@@ -1,6 +1,6 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { MAX_LINE_CHARS } from "../triage/welcome/constants.js";
 import { evaluateHealth, healthHistoryPath } from "./health.js";
 /** Repeat-suppression window for the budgeted eval session nudge (#1703 / #1279 parity). */
@@ -125,15 +125,16 @@ function appendEvalReadbackHistory(projectRoot, nudgeKey, line, options = {}) {
         line,
     };
     try {
-        assertWriteTargetSafe(projectRoot, path);
-        mkdirSync(join(path, ".."), { recursive: true });
-        appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
+        // #2980 wave C: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(projectRoot),
+            target: path,
+            data: `${JSON.stringify(record)}\n`,
+            mode: "append",
+        });
     }
-    catch (err) {
-        if (err instanceof ProjectionContainmentError) {
-            throw err;
-        }
-        // observability only
+    catch {
+        // observability only (containment refusals included — outer caller may swallow)
     }
 }
 function failedGateCount(report) {

package/dist/eval/run.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
-import { appendFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { join, resolve } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
-import { assertWriteTargetSafe } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveEvalPath } from "../layout/resolve.js";
 import { BYTE_DIFF_WHOLE_FILE_THRESHOLD, InstrumentedVbriefCrud } from "./crud-telemetry.js";
 import { evaluateHealth } from "./health.js";
@@ -94,16 +94,28 @@ function gradeCrudSurgicalUpdate(context) {
     };
 }
 function seedHealthFixture(tempDir) {
-    writeFileSync(join(tempDir, "xbrief", "PROJECT-DEFINITION.xbrief.json"), JSON.stringify({
-        xBRIEFInfo: { version: "0.6" },
-        plan: {
-            title: "Golden health fixture",
-            status: "running",
-            items: [],
-            "x-directive/policy": { triageScope: [{ rule: "all-open" }] },
-        },
-    }), "utf8");
-    writeFileSync(join(tempDir, "AGENTS.md"), "<!-- deft:managed-section v3 -->\n<!-- /deft:managed-section -->\n", "utf8");
+    const root = resolve(tempDir);
+    // #2980 wave C: product fixture seed routes through containedWrite.
+    containedWrite({
+        root,
+        target: join("xbrief", "PROJECT-DEFINITION.xbrief.json"),
+        data: JSON.stringify({
+            xBRIEFInfo: { version: "0.6" },
+            plan: {
+                title: "Golden health fixture",
+                status: "running",
+                items: [],
+                "x-directive/policy": { triageScope: [{ rule: "all-open" }] },
+            },
+        }),
+        mode: "replace",
+    });
+    containedWrite({
+        root,
+        target: "AGENTS.md",
+        data: "<!-- deft:managed-section v3 -->\n<!-- /deft:managed-section -->\n",
+        mode: "replace",
+    });
 }
 function gradeHealthFixture(context) {
     seedHealthFixture(context.tempDir);
@@ -195,9 +207,13 @@ export function goldenRunsHistoryPath(projectRoot) {
 /** Append one golden run to the versioned ledger (#1703 Tier 2). */
 export function persistGoldenRun(projectRoot, record) {
     const path = goldenRunsHistoryPath(projectRoot);
-    assertWriteTargetSafe(projectRoot, path);
-    mkdirSync(dirname(path), { recursive: true });
-    appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
+    // #2980 wave C: product write sink routes through containedWrite.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: path,
+        data: `${JSON.stringify(record)}\n`,
+        mode: "append",
+    });
 }
 /** Stable hash for rotating holdout selection (#1703 Goodhart mitigation). */
 export function holdoutRotationIndex(directiveVersion, model, holdoutCount) {

package/dist/events/attribution-enrichment.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { inferRepoFromGit } from "../triage/queue/repo.js";
 /** Record-shape version for attribution ledger entries (#2376). Bump on shape changes. */
 export const ATTRIBUTION_SCHEMA_VERSION = 1;
@@ -26,8 +27,13 @@ export function resolveInstallId(projectRoot) {
     }
     try {
         const id = randomUUID();
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, `${id}\n`, "utf8");
+        // #2951 Phase 2: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(projectRoot),
+            target: path,
+            data: `${id}\n`,
+            mode: "replace",
+        });
         return id;
     }
     catch {

package/dist/finish-loop/directive-finish-loop.d.ts

@@ -0,0 +1,37 @@
+/**
+ * directive:finish-loop — outer walk-away cascade (#871 Wave 5).
+ *
+ * 1. Gate on finish-loop human-origin grant (or DEFT_ALLOW_FINISH_LOOP)
+ * 2. Scan xbrief queue (active/pending)
+ * 3. Append progress JSONL each iteration
+ * 4. When --pr supplied, run pr:finish-loop
+ * 5. Implementation steps are agent-owned: CLI emits AGENT_STEP and exits
+ *    ACTION_REQUIRED so a live agent continues; full autonomous coding is
+ *    not inlined in the Taskfile.
+ *
+ * Halt: empty queue | grant expiry/deny | max iterations | gate deny
+ */
+import { type PrFinishLoopOptions, runPrFinishLoop } from "./pr-finish-loop.js";
+import { scanFinishLoopQueue } from "./queue.js";
+import { type DirectiveFinishLoopResult } from "./types.js";
+export declare const DEFAULT_MAX_ITERATIONS = 20;
+export interface DirectiveFinishLoopOptions {
+    readonly projectRoot: string;
+    /** Optional PR number to shepherd via pr:finish-loop this iteration. */
+    readonly prNumber?: number | null;
+    readonly repo?: string | null;
+    readonly maxIterations?: number;
+    readonly maxWaitMinutes?: number;
+    readonly pollSeconds?: number;
+    readonly oneShot?: boolean;
+    readonly merge?: boolean;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly now?: Date;
+    readonly skipGrantGate?: boolean;
+    /** Inject for tests. */
+    readonly scanQueueFn?: typeof scanFinishLoopQueue;
+    readonly prFinishLoopFn?: (opts: PrFinishLoopOptions) => ReturnType<typeof runPrFinishLoop>;
+    readonly writeProgress?: boolean;
+}
+export declare function runDirectiveFinishLoop(options: DirectiveFinishLoopOptions): DirectiveFinishLoopResult;
+//# sourceMappingURL=directive-finish-loop.d.ts.map