@gugu910/pi-slack-bridge 0.1.3

package/dist/slack-upload.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSlackUploadFiletype = inferSlackUploadFiletype;
+exports.chooseSlackSnippetType = chooseSlackSnippetType;
+exports.resolveSlackUploadPath = resolveSlackUploadPath;
+exports.prepareSlackUpload = prepareSlackUpload;
+exports.performSlackUpload = performSlackUpload;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const FILETYPE_ALIASES = {
+    cjs: "javascript",
+    htm: "html",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    md: "markdown",
+    py: "python",
+    rb: "ruby",
+    sh: "shell",
+    ts: "typescript",
+    tsx: "typescript",
+    yml: "yaml",
+    zsh: "shell",
+};
+const DEFAULT_SNIPPET_TYPE = "text";
+const MAX_SNIPPET_BYTES = 1_000_000;
+function inferSlackUploadFiletype(filename, explicitFiletype) {
+    const raw = (explicitFiletype ?? node_path_1.default.extname(filename ?? "").slice(1)).trim().toLowerCase();
+    if (!raw)
+        return undefined;
+    return FILETYPE_ALIASES[raw] ?? raw;
+}
+function chooseSlackSnippetType(upload) {
+    if (upload.source !== "content")
+        return undefined;
+    if (upload.byteLength > MAX_SNIPPET_BYTES)
+        return undefined;
+    return inferSlackUploadFiletype(upload.filename, upload.filetype) ?? DEFAULT_SNIPPET_TYPE;
+}
+function isWithinRoot(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${node_path_1.default.sep}`);
+}
+async function resolveSlackUploadPath(inputPath, cwd, tmpdir, fsDeps = {}) {
+    const { realpathImpl = promises_1.realpath, statImpl = promises_1.stat } = fsDeps;
+    const requestedPath = inputPath.trim();
+    if (!requestedPath) {
+        throw new Error("path is required when uploading from a local file.");
+    }
+    const candidate = node_path_1.default.isAbsolute(requestedPath)
+        ? requestedPath
+        : node_path_1.default.resolve(cwd, requestedPath);
+    const [resolvedCandidate, resolvedCwd, resolvedTmpdir] = await Promise.all([
+        realpathImpl(candidate),
+        realpathImpl(cwd),
+        realpathImpl(tmpdir),
+    ]);
+    if (!isWithinRoot(resolvedCandidate, resolvedCwd) &&
+        !isWithinRoot(resolvedCandidate, resolvedTmpdir)) {
+        throw new Error("For safety, slack_upload only allows local file paths inside the current working directory or the system temp directory. For other files, read the content explicitly and upload it via the content parameter.");
+    }
+    const fileStats = await statImpl(resolvedCandidate);
+    if (!fileStats.isFile()) {
+        throw new Error(`Local upload path is not a file: ${requestedPath}`);
+    }
+    return resolvedCandidate;
+}
+async function prepareSlackUpload(params, cwd, tmpdir, fsDeps = {}) {
+    const { readFileImpl = promises_1.readFile } = fsDeps;
+    const hasContent = typeof params.content === "string";
+    const hasPath = typeof params.path === "string" && params.path.trim().length > 0;
+    if (hasContent === hasPath) {
+        throw new Error("Provide exactly one of content or path.");
+    }
+    let bytes;
+    let filename = params.filename?.trim();
+    let resolvedPath;
+    let source;
+    if (hasContent) {
+        if (!filename) {
+            throw new Error("filename is required when uploading inline content.");
+        }
+        bytes = Buffer.from(params.content ?? "", "utf8");
+        source = "content";
+    }
+    else {
+        resolvedPath = await resolveSlackUploadPath(params.path, cwd, tmpdir, fsDeps);
+        bytes = await readFileImpl(resolvedPath);
+        filename = filename || node_path_1.default.basename(resolvedPath);
+        source = "path";
+    }
+    const sanitizedFilename = filename?.trim();
+    if (!sanitizedFilename) {
+        throw new Error("filename is required.");
+    }
+    const filetype = inferSlackUploadFiletype(sanitizedFilename, params.filetype);
+    const title = params.title?.trim() || sanitizedFilename;
+    return {
+        bytes,
+        byteLength: bytes.byteLength,
+        filename: sanitizedFilename,
+        title,
+        filetype,
+        snippetType: chooseSlackSnippetType({
+            source,
+            byteLength: bytes.byteLength,
+            filename: sanitizedFilename,
+            filetype,
+        }),
+        source,
+        ...(resolvedPath ? { resolvedPath } : {}),
+    };
+}
+async function performSlackUpload({ upload, channelId, threadTs, slack, token, fetchImpl = fetch, }) {
+    const getUploadResponse = await slack("files.getUploadURLExternal", token, {
+        filename: upload.filename,
+        length: upload.byteLength,
+        ...(upload.snippetType ? { snippet_type: upload.snippetType } : {}),
+    });
+    const uploadUrl = typeof getUploadResponse.upload_url === "string" ? getUploadResponse.upload_url : null;
+    const fileId = typeof getUploadResponse.file_id === "string" ? getUploadResponse.file_id : null;
+    if (!uploadUrl || !fileId) {
+        throw new Error("Slack files.getUploadURLExternal did not return an upload URL and file ID.");
+    }
+    const rawBody = new Uint8Array(upload.bytes.byteLength);
+    rawBody.set(upload.bytes);
+    const rawUploadResponse = await fetchImpl(uploadUrl, {
+        method: "POST",
+        headers: {
+            "Content-Length": String(upload.byteLength),
+            "Content-Type": upload.source === "content" ? "text/plain; charset=utf-8" : "application/octet-stream",
+        },
+        body: new Blob([rawBody]),
+    });
+    if (!rawUploadResponse.ok) {
+        const details = (await rawUploadResponse.text()).trim();
+        throw new Error(`Slack raw upload failed (${rawUploadResponse.status}${rawUploadResponse.statusText ? ` ${rawUploadResponse.statusText}` : ""})${details ? `: ${details}` : ""}`);
+    }
+    const response = await slack("files.completeUploadExternal", token, {
+        files: [{ id: fileId, title: upload.title }],
+        channel_id: channelId,
+        ...(threadTs ? { thread_ts: threadTs } : {}),
+    });
+    return { fileId, response };
+}

package/dist/task-assignments.js

@@ -0,0 +1,403 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTaskAssignmentsFromMessage = extractTaskAssignmentsFromMessage;
+exports.normalizeTrackedTaskAssignments = normalizeTrackedTaskAssignments;
+exports.resolveTaskAssignments = resolveTaskAssignments;
+exports.hasTaskAssignmentStatusChange = hasTaskAssignmentStatusChange;
+exports.buildTaskAssignmentReport = buildTaskAssignmentReport;
+exports.getPendingTaskAssignmentReport = getPendingTaskAssignmentReport;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const WORKTREE_BRANCH_REGEX = /\bgit\s+worktree\s+add\b[^\n]*?\s-b\s+([^\s`"',;]+)/i;
+const CHECKOUT_BRANCH_REGEX = /\bgit\s+(?:checkout|switch)\s+-[cb]\s+([^\s`"',;]+)/i;
+const EXPLICIT_BRANCH_LABEL_REGEX = /\bbranch(?:\s+to\s+work\s+on|\s+name)?\s*:\s*[`"']?([A-Za-z0-9._/-]+)\b/i;
+const ISSUE_PR_LINE_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?issue\/pr\s*:\s*#(\d+)\b/gi;
+const ISSUE_LINE_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?issue\s*:\s*#(\d+)\b/gi;
+const ISSUE_HEADING_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?issue\s+#(\d+)(?=\s*(?:[—–:-]|$))/gi;
+const TASK_ISSUE_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?task\s*:\s*[^\n#]*\bissue\s*#(\d+)\b/gi;
+const NEW_TASK_ISSUE_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?new(?:\s+[a-z-]+){0,3}\s+task\b[^\n#]*\bissue\s*#(\d+)\b/gi;
+const FOLLOW_UP_TASK_ISSUE_REGEX = /(?:^|\n)\s*(?:[-*]\s*)?follow-up\s+task(?:\s+from)?\s+issue\s*#(\d+)\b/gi;
+async function runCommand(file, args, cwd, runner) {
+    try {
+        const result = await runner(file, args, { cwd, encoding: "utf-8" });
+        const stdout = typeof result.stdout === "string" ? result.stdout : result.stdout?.toString();
+        const trimmed = stdout?.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runJsonCommand(file, args, cwd, runner) {
+    const stdout = await runCommand(file, args, cwd, runner);
+    if (!stdout) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeMessageForTaskParsing(message) {
+    return message.replace(/\r\n/g, "\n").replace(/[`*_]/g, "");
+}
+function parseBranch(message) {
+    const normalized = normalizeMessageForTaskParsing(message);
+    const match = normalized.match(WORKTREE_BRANCH_REGEX) ??
+        normalized.match(CHECKOUT_BRANCH_REGEX) ??
+        normalized.match(EXPLICIT_BRANCH_LABEL_REGEX);
+    const branch = match?.[1]?.trim().replace(/[.,;:]+$/, "");
+    return branch ? branch : null;
+}
+function parseIssueNumbers(message) {
+    const normalized = normalizeMessageForTaskParsing(message);
+    const issueNumbers = new Set();
+    for (const regex of [
+        ISSUE_PR_LINE_REGEX,
+        ISSUE_LINE_REGEX,
+        ISSUE_HEADING_REGEX,
+        TASK_ISSUE_REGEX,
+        NEW_TASK_ISSUE_REGEX,
+        FOLLOW_UP_TASK_ISSUE_REGEX,
+    ]) {
+        for (const match of normalized.matchAll(regex)) {
+            const issueNumber = Number(match[1]);
+            if (Number.isFinite(issueNumber)) {
+                issueNumbers.add(issueNumber);
+            }
+        }
+    }
+    return [...issueNumbers].sort((left, right) => left - right);
+}
+function extractTaskAssignmentsFromMessage(message) {
+    const branch = parseBranch(message);
+    return parseIssueNumbers(message).map((issueNumber) => ({ issueNumber, branch }));
+}
+function compareTaskAssignmentRecency(left, right) {
+    const updatedAt = Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+    if (updatedAt !== 0) {
+        return updatedAt;
+    }
+    const createdAt = Date.parse(right.createdAt) - Date.parse(left.createdAt);
+    if (createdAt !== 0) {
+        return createdAt;
+    }
+    return right.id - left.id;
+}
+function canonicalizeTaskAssignmentFromSourceMessage(assignment, sourceMessagesById) {
+    if (assignment.sourceMessageId == null) {
+        return assignment;
+    }
+    const sourceMessage = sourceMessagesById.get(assignment.sourceMessageId);
+    if (!sourceMessage) {
+        return assignment;
+    }
+    const parsedAssignments = extractTaskAssignmentsFromMessage(sourceMessage);
+    if (parsedAssignments.length === 0) {
+        return null;
+    }
+    const matchingAssignment = parsedAssignments.find((candidate) => candidate.issueNumber === assignment.issueNumber);
+    if (matchingAssignment) {
+        if (matchingAssignment.branch === assignment.branch) {
+            return assignment;
+        }
+        return { ...assignment, branch: matchingAssignment.branch };
+    }
+    if (parsedAssignments.length === 1) {
+        const [canonicalAssignment] = parsedAssignments;
+        return {
+            ...assignment,
+            issueNumber: canonicalAssignment.issueNumber,
+            branch: canonicalAssignment.branch,
+        };
+    }
+    return null;
+}
+function normalizeTrackedTaskAssignments(assignments, sourceMessagesById = new Map()) {
+    const canonicalAssignments = assignments
+        .map((assignment) => canonicalizeTaskAssignmentFromSourceMessage(assignment, sourceMessagesById))
+        .filter((assignment) => assignment != null)
+        .sort(compareTaskAssignmentRecency);
+    const visibleAssignments = [];
+    const seenIssueNumbers = new Set();
+    for (const assignment of canonicalAssignments) {
+        if (seenIssueNumbers.has(assignment.issueNumber)) {
+            continue;
+        }
+        seenIssueNumbers.add(assignment.issueNumber);
+        visibleAssignments.push(assignment);
+    }
+    return visibleAssignments;
+}
+function normalizePullRequests(prs) {
+    if (!Array.isArray(prs)) {
+        return [];
+    }
+    return prs.filter((pr) => typeof pr?.number === "number" &&
+        typeof pr?.state === "string" &&
+        typeof pr?.headRefName === "string");
+}
+function chooseBestPullRequest(prs) {
+    if (prs.length === 0) {
+        return null;
+    }
+    const score = (pr) => {
+        if (pr.mergedAt)
+            return 3;
+        if (pr.state.toUpperCase() === "OPEN")
+            return 2;
+        return 1;
+    };
+    return ([...prs].sort((left, right) => {
+        const byScore = score(right) - score(left);
+        if (byScore !== 0)
+            return byScore;
+        const leftMergedAt = left.mergedAt ? Date.parse(left.mergedAt) : 0;
+        const rightMergedAt = right.mergedAt ? Date.parse(right.mergedAt) : 0;
+        if (rightMergedAt !== leftMergedAt)
+            return rightMergedAt - leftMergedAt;
+        return right.number - left.number;
+    })[0] ?? null);
+}
+async function resolveBaseRef(cwd, runner) {
+    for (const ref of ["origin/main", "main"]) {
+        const resolved = await runCommand("git", ["rev-parse", "--verify", "--quiet", ref], cwd, runner);
+        if (resolved) {
+            return ref;
+        }
+    }
+    return null;
+}
+async function getBranchAheadCount(branch, baseRef, cwd, runner) {
+    if (!branch || !baseRef) {
+        return 0;
+    }
+    let maxAheadCount = 0;
+    const refs = [...new Set([branch, `origin/${branch}`])];
+    for (const ref of refs) {
+        const resolved = await runCommand("git", ["rev-parse", "--verify", "--quiet", ref], cwd, runner);
+        if (!resolved) {
+            continue;
+        }
+        const count = await runCommand("git", ["rev-list", "--count", `${baseRef}..${ref}`], cwd, runner);
+        const aheadCount = Number.parseInt(count ?? "0", 10);
+        if (Number.isFinite(aheadCount) && aheadCount > maxAheadCount) {
+            maxAheadCount = aheadCount;
+        }
+    }
+    return maxAheadCount;
+}
+async function getPullRequestForBranch(branch, cwd, runner) {
+    if (!branch) {
+        return null;
+    }
+    const rawPrs = await runJsonCommand("gh", [
+        "pr",
+        "list",
+        "--head",
+        branch,
+        "--state",
+        "all",
+        "--json",
+        "number,state,mergedAt,headRefName",
+    ], cwd, runner);
+    if (rawPrs === undefined) {
+        return undefined;
+    }
+    const prs = normalizePullRequests(rawPrs);
+    return chooseBestPullRequest(prs);
+}
+async function getPullRequestByNumber(prNumber, cwd, runner) {
+    const pr = await runJsonCommand("gh", ["pr", "view", String(prNumber), "--json", "number,state,mergedAt,headRefName"], cwd, runner);
+    if (pr === undefined) {
+        return undefined;
+    }
+    return normalizePullRequests([pr])[0] ?? null;
+}
+async function getIssueByNumber(issueNumber, cwd, runner) {
+    const issue = await runJsonCommand("gh", ["issue", "view", String(issueNumber), "--json", "number,state"], cwd, runner);
+    if (issue === undefined) {
+        return undefined;
+    }
+    if (issue && typeof issue.number === "number" && typeof issue.state === "string") {
+        return issue;
+    }
+    return null;
+}
+function normalizeIssueState(issue) {
+    const state = issue?.state?.toUpperCase();
+    if (state === "OPEN" || state === "CLOSED") {
+        return state;
+    }
+    return null;
+}
+function hasTrackedPullRequestLink(assignment, pr) {
+    return (assignment.prNumber === pr.number ||
+        assignment.status === "pr_open" ||
+        assignment.status === "pr_merged" ||
+        assignment.status === "pr_closed");
+}
+function resolveTaskStatus(assignment, branchAheadCount, pr) {
+    if (pr === undefined && assignment.status.startsWith("pr_")) {
+        return { nextStatus: assignment.status, nextPrNumber: assignment.prNumber };
+    }
+    if (pr?.state.toUpperCase() === "OPEN") {
+        return { nextStatus: "pr_open", nextPrNumber: pr.number };
+    }
+    if (pr?.mergedAt) {
+        if (hasTrackedPullRequestLink(assignment, pr)) {
+            return { nextStatus: "pr_merged", nextPrNumber: pr.number };
+        }
+        if (branchAheadCount > 0) {
+            return { nextStatus: "branch_pushed", nextPrNumber: null };
+        }
+        return { nextStatus: "assigned", nextPrNumber: null };
+    }
+    if (pr) {
+        if (hasTrackedPullRequestLink(assignment, pr)) {
+            return { nextStatus: "pr_closed", nextPrNumber: pr.number };
+        }
+        if (branchAheadCount > 0) {
+            return { nextStatus: "branch_pushed", nextPrNumber: null };
+        }
+        return { nextStatus: "assigned", nextPrNumber: null };
+    }
+    if (branchAheadCount > 0) {
+        return { nextStatus: "branch_pushed", nextPrNumber: null };
+    }
+    return { nextStatus: "assigned", nextPrNumber: null };
+}
+async function resolveTaskAssignments(assignments, cwd = process.cwd(), runner = execFileAsync) {
+    if (assignments.length === 0) {
+        return [];
+    }
+    const baseRef = await resolveBaseRef(cwd, runner);
+    const branchProgressCache = new Map();
+    const pullRequestByNumberCache = new Map();
+    const issueByNumberCache = new Map();
+    const resolveBranchProgress = (branch) => {
+        const cacheKey = branch ?? "";
+        const cached = branchProgressCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const promise = Promise.all([
+            getBranchAheadCount(branch, baseRef, cwd, runner),
+            getPullRequestForBranch(branch, cwd, runner),
+        ]).then(([branchAheadCount, pr]) => ({ branchAheadCount, pr }));
+        branchProgressCache.set(cacheKey, promise);
+        return promise;
+    };
+    const resolvePullRequestByNumber = (prNumber) => {
+        const cached = pullRequestByNumberCache.get(prNumber);
+        if (cached) {
+            return cached;
+        }
+        const promise = getPullRequestByNumber(prNumber, cwd, runner);
+        pullRequestByNumberCache.set(prNumber, promise);
+        return promise;
+    };
+    const resolveIssueByNumber = (issueNumber) => {
+        const cached = issueByNumberCache.get(issueNumber);
+        if (cached) {
+            return cached;
+        }
+        const promise = getIssueByNumber(issueNumber, cwd, runner);
+        issueByNumberCache.set(issueNumber, promise);
+        return promise;
+    };
+    return Promise.all(assignments.map(async (assignment) => {
+        const { branchAheadCount, pr } = await resolveBranchProgress(assignment.branch);
+        const resolvedPr = pr == null && assignment.prNumber != null
+            ? await resolvePullRequestByNumber(assignment.prNumber)
+            : pr;
+        const issueState = normalizeIssueState(await resolveIssueByNumber(assignment.issueNumber));
+        const { nextStatus, nextPrNumber } = resolveTaskStatus(assignment, branchAheadCount, resolvedPr);
+        return {
+            ...assignment,
+            nextStatus,
+            nextPrNumber,
+            branchAheadCount,
+            issueState,
+        };
+    }));
+}
+function hasTaskAssignmentStatusChange(assignment) {
+    return (assignment.status !== assignment.nextStatus || assignment.prNumber !== assignment.nextPrNumber);
+}
+function formatTaskProgressFragment(assignment) {
+    switch (assignment.status) {
+        case "pr_merged":
+            return `#${assignment.issueNumber} → PR #${assignment.prNumber ?? "?"} MERGED ✅`;
+        case "pr_open":
+            return `#${assignment.issueNumber} → PR #${assignment.prNumber ?? "?"} OPEN 🔄`;
+        case "pr_closed":
+            return `#${assignment.issueNumber} → PR #${assignment.prNumber ?? "?"} CLOSED ⚠️`;
+        case "branch_pushed":
+            return `#${assignment.issueNumber} → commits on ${assignment.branch ?? "tracked branch"}, no PR 👀`;
+        case "assigned":
+        default:
+            return `#${assignment.issueNumber} → no commits, no PR ⚠️`;
+    }
+}
+function getVisibleTaskAssignmentReportEntries(assignments) {
+    return assignments.filter((assignment) => assignment.issueState !== "CLOSED");
+}
+function formatAgentLabel(agentId, agentsById) {
+    const agent = agentsById.get(agentId);
+    if (!agent) {
+        return agentId;
+    }
+    return `${agent.emoji} ${agent.name}`.trim();
+}
+function getAgentSortKey(agentId, agentsById) {
+    const agent = agentsById.get(agentId);
+    return agent?.name ?? agentId;
+}
+function buildTaskAssignmentReport(assignments, agentsById, cycleStartedAt) {
+    const visibleAssignments = getVisibleTaskAssignmentReportEntries(assignments);
+    if (visibleAssignments.length === 0) {
+        return null;
+    }
+    const grouped = new Map();
+    for (const assignment of visibleAssignments) {
+        const bucket = grouped.get(assignment.agentId);
+        if (bucket) {
+            bucket.push(assignment);
+        }
+        else {
+            grouped.set(assignment.agentId, [assignment]);
+        }
+    }
+    const lines = [...grouped.entries()]
+        .sort(([leftAgentId], [rightAgentId]) => {
+        const leftLabel = getAgentSortKey(leftAgentId, agentsById);
+        const rightLabel = getAgentSortKey(rightAgentId, agentsById);
+        return leftLabel.localeCompare(rightLabel);
+    })
+        .map(([agentId, agentAssignments]) => {
+        const summary = [...agentAssignments]
+            .sort((left, right) => left.issueNumber - right.issueNumber)
+            .map((assignment) => formatTaskProgressFragment(assignment))
+            .join("; ");
+        return `- ${formatAgentLabel(agentId, agentsById)}: ${summary}`;
+    });
+    const header = cycleStartedAt
+        ? ["RALPH LOOP — WORKER STATUS:", `Timestamp: ${cycleStartedAt}`]
+        : ["RALPH LOOP — WORKER STATUS:"];
+    return [...header, ...lines].join("\n");
+}
+function getPendingTaskAssignmentReport(assignments, agentsById, lastDeliveredSignature, cycleStartedAt) {
+    const signature = buildTaskAssignmentReport(assignments, agentsById);
+    if (!signature || signature === lastDeliveredSignature) {
+        return null;
+    }
+    const message = buildTaskAssignmentReport(assignments, agentsById, cycleStartedAt);
+    if (!message) {
+        return null;
+    }
+    return { message, signature };
+}

package/dist/ttl-cache.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtlSet = exports.TtlCache = void 0;
+/**
+ * Lightweight TTL + max-size cache.
+ *
+ * Entries expire after `ttlMs` milliseconds and are lazily evicted on
+ * access.  When the cache exceeds `maxSize`, the oldest entry (by
+ * insertion / last-update order) is dropped — Map iteration order
+ * guarantees FIFO.
+ */
+class TtlCache {
+    map = new Map();
+    maxSize;
+    ttlMs;
+    now;
+    constructor(options) {
+        this.maxSize = options.maxSize;
+        this.ttlMs = options.ttlMs;
+        this.now = options.now ?? (() => Date.now());
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (this.now() - entry.touchedAt > this.ttlMs) {
+            this.map.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        // Delete first so re-insertion moves the key to the end (Map ordering).
+        this.map.delete(key);
+        this.map.set(key, { value, touchedAt: this.now() });
+        this.evictOverflow();
+        return this;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    get size() {
+        return this.map.size;
+    }
+    /** Iterate live (non-expired) entries. */
+    *entries() {
+        const now = this.now();
+        for (const [key, entry] of this.map) {
+            if (now - entry.touchedAt <= this.ttlMs) {
+                yield [key, entry.value];
+            }
+        }
+    }
+    /** Sweep all expired entries in one pass. */
+    sweep() {
+        const now = this.now();
+        let swept = 0;
+        for (const [key, entry] of this.map) {
+            if (now - entry.touchedAt > this.ttlMs) {
+                this.map.delete(key);
+                swept++;
+            }
+        }
+        return swept;
+    }
+    clear() {
+        this.map.clear();
+    }
+    evictOverflow() {
+        while (this.map.size > this.maxSize) {
+            const oldest = this.map.keys().next();
+            if (oldest.done)
+                break;
+            this.map.delete(oldest.value);
+        }
+    }
+}
+exports.TtlCache = TtlCache;
+/**
+ * TTL + max-size Set — thin wrapper around TtlCache<V, true>.
+ */
+class TtlSet {
+    cache;
+    constructor(options) {
+        this.cache = new TtlCache(options);
+    }
+    add(value) {
+        this.cache.set(value, true);
+        return this;
+    }
+    has(value) {
+        return this.cache.has(value);
+    }
+    delete(value) {
+        return this.cache.delete(value);
+    }
+    get size() {
+        return this.cache.size;
+    }
+    sweep() {
+        return this.cache.sweep();
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.TtlSet = TtlSet;