@j0hanz/fetch-url-mcp 1.1.0 → 1.1.2

package/dist/markdown-cleanup.js

@@ -1,4 +1,5 @@
 import { config } from './config.js';
+import { FetchError } from './errors.js';
 // --- Constants & Regex ---
 const MAX_LINE_LENGTH = 80;
 const REGEX = {
@@ -24,20 +25,39 @@ const REGEX = {
     SPACING_ESCAPES: /\\([[\].])/g,
     SPACING_LIST_NUM_COMBINED: /^((?![-*+] |\d+\. |[ \t]).+)\n((?:[-*+]|\d+\.) )/gm,
     NESTED_LIST_INDENT: /^( +)((?:[-*+])|\d+\.)\s/gm,
-    TYPEDOC: /(`+)(?:(?!\1)[\s\S])*?\1|\s?\/\\?\*[\s\S]*?\\?\*\//g,
+    TYPEDOC_COMMENT: /(`+)(?:(?!\1)[\s\S])*?\1|\s?\/\\?\*[\s\S]*?\\?\*\//g,
 };
 const HEADING_KEYWORDS = new Set(config.markdownCleanup.headingKeywords.map((value) => value.toLocaleLowerCase(config.i18n.locale)));
 const SPECIAL_PREFIXES = /^(?:example|note|tip|warning|important|caution):\s+\S/i;
+const TOC_SCAN_LIMIT = 20;
+const TOC_MAX_NON_EMPTY = 12;
+const TOC_LINK_RATIO_THRESHOLD = 0.8;
+const TYPEDOC_PREFIXES = [
+    'Defined in:',
+    'Returns:',
+    'Since:',
+    'See also:',
+];
+function throwIfAborted(signal, url, stage) {
+    if (!signal?.aborted)
+        return;
+    throw new FetchError('Request was canceled', url, 499, {
+        reason: 'aborted',
+        stage,
+    });
+}
 // --- Helper Functions ---
 function getLineEnding(content) {
     return content.includes('\r\n') ? '\r\n' : '\n';
 }
+function isBlank(line) {
+    return line === undefined || line.trim().length === 0;
+}
 function hasFollowingContent(lines, startIndex) {
     // Optimization: Bound lookahead to avoid checking too many lines in huge files
     const max = Math.min(lines.length, startIndex + 50);
     for (let i = startIndex + 1; i < max; i++) {
-        const line = lines[i];
-        if (line && line.trim().length > 0)
+        if (!isBlank(lines[i]))
             return true;
     }
     return false;
@@ -100,29 +120,55 @@ function getHeadingPrefix(trimmed) {
     return isTitleCaseOrKeyword(trimmed) ? '## ' : null;
 }
 // Optimized TOC detection
-function hasTocBlock(lines, headingIndex) {
-    const lookaheadMax = Math.min(lines.length, headingIndex + 8);
+function getTocBlockStats(lines, headingIndex) {
+    let total = 0;
+    let linkCount = 0;
+    let nonLinkCount = 0;
+    const lookaheadMax = Math.min(lines.length, headingIndex + TOC_SCAN_LIMIT);
     for (let i = headingIndex + 1; i < lookaheadMax; i++) {
         const line = lines[i];
-        if (!line || line.trim().length === 0)
+        if (!line)
             continue;
-        if (REGEX.TOC_LINK.test(line))
-            return true;
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (REGEX.HEADING_MARKER.test(trimmed))
+            break;
+        total += 1;
+        if (REGEX.TOC_LINK.test(trimmed))
+            linkCount += 1;
+        else
+            nonLinkCount += 1;
+        if (total >= TOC_MAX_NON_EMPTY)
+            break;
     }
-    return false;
+    return { total, linkCount, nonLinkCount };
 }
 function skipTocLines(lines, startIndex) {
     for (let i = startIndex; i < lines.length; i++) {
         const line = lines[i];
-        if (!line)
+        if (line === undefined)
             continue;
-        if (line.trim().length === 0)
+        const trimmed = line.trim();
+        if (!trimmed)
             continue;
-        if (!REGEX.TOC_LINK.test(line))
+        if (!REGEX.TOC_LINK.test(trimmed))
             return i;
     }
     return lines.length;
 }
+function isTypeDocArtifactLine(line) {
+    const trimmed = line.trim();
+    for (const prefix of TYPEDOC_PREFIXES) {
+        if (!trimmed.startsWith(prefix))
+            continue;
+        const rest = trimmed.slice(prefix.length).trimStart();
+        if (!rest.startsWith('**`'))
+            return false;
+        return rest.includes('`**');
+    }
+    return false;
+}
 // --- Main Processing Logic ---
 function tryPromoteOrphan(lines, i, trimmed) {
     const prevLine = lines[i - 1];
@@ -137,13 +183,19 @@ function tryPromoteOrphan(lines, i, trimmed) {
         return null;
     return `${prefix}${trimmed}`;
 }
-function shouldSkipAsToc(lines, i, trimmed, removeToc) {
-    if (removeToc && REGEX.TOC_HEADING.test(trimmed) && hasTocBlock(lines, i)) {
-        return skipTocLines(lines, i + 1);
-    }
-    return null;
+function shouldSkipAsToc(lines, i, trimmed, removeToc, options) {
+    if (!removeToc || !REGEX.TOC_HEADING.test(trimmed))
+        return null;
+    const { total, linkCount, nonLinkCount } = getTocBlockStats(lines, i);
+    if (total === 0 || nonLinkCount > 0)
+        return null;
+    const ratio = linkCount / total;
+    if (ratio <= TOC_LINK_RATIO_THRESHOLD)
+        return null;
+    throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:toc');
+    return skipTocLines(lines, i + 1);
 }
-function preprocessLines(lines) {
+function preprocessLines(lines, options) {
     const processedLines = [];
     const len = lines.length;
     const promote = config.markdownCleanup.promoteOrphanHeadings;
@@ -158,12 +210,13 @@ function preprocessLines(lines) {
         const trimmed = line.trim();
         if (REGEX.EMPTY_HEADING_LINE.test(trimmed))
             continue;
-        const tocSkip = shouldSkipAsToc(lines, i, trimmed, removeToc);
+        const tocSkip = shouldSkipAsToc(lines, i, trimmed, removeToc, options);
         if (tocSkip !== null) {
             skipUntil = tocSkip;
             continue;
         }
         if (promote && trimmed.length > 0) {
+            throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:promote');
             const promoted = tryPromoteOrphan(lines, i, trimmed);
             if (promoted)
                 line = promoted;
@@ -173,28 +226,35 @@ function preprocessLines(lines) {
     return processedLines.join('\n');
 }
 // Process a block of non-fence lines
-function processTextBuffer(lines) {
+function processTextBuffer(lines, options) {
     if (lines.length === 0)
         return '';
-    const text = preprocessLines(lines);
-    return applyGlobalRegexes(text);
+    const text = preprocessLines(lines, options);
+    return applyGlobalRegexes(text, options);
 }
-function applyGlobalRegexes(text) {
+function applyGlobalRegexes(text, options) {
     let result = text;
+    throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:headings');
     // fixAndSpaceHeadings
     result = result
         .replace(REGEX.HEADING_SPACING, '$1\n\n$2')
         .replace(REGEX.HEADING_CODE_BLOCK, '$1\n\n```')
         .replace(REGEX.HEADING_CAMEL_CASE, '$1\n\n$2');
-    // removeTypeDocComments
     if (config.markdownCleanup.removeTypeDocComments) {
-        result = result.replace(REGEX.TYPEDOC, (match) => match.startsWith('`') ? match : '');
+        throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:typedoc');
+        result = result
+            .split('\n')
+            .filter((line) => !isTypeDocArtifactLine(line))
+            .join('\n');
+        result = result.replace(REGEX.TYPEDOC_COMMENT, (match) => match.startsWith('`') ? match : '');
     }
     if (config.markdownCleanup.removeSkipLinks) {
+        throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:skip-links');
         result = result
             .replace(REGEX.ZERO_WIDTH_ANCHOR, '')
             .replace(REGEX.COMBINED_LINE_REMOVALS, '');
     }
+    throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:spacing');
     // normalizeSpacing
     result = result
         .replace(REGEX.SPACING_LINK_FIX, ']($1)\n\n[')
@@ -204,6 +264,7 @@ function applyGlobalRegexes(text) {
         .replace(REGEX.SPACING_LIST_NUM_COMBINED, '$1\n\n$2')
         .replace(REGEX.DOUBLE_NEWLINE_REDUCER, '\n\n');
     result = normalizeNestedListIndentation(result);
+    throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:properties');
     // fixProperties
     for (let k = 0; k < 3; k++) {
         const next = result.replace(REGEX.CONCATENATED_PROPS, '$1$2\n\n$3');
@@ -251,22 +312,23 @@ function handleFencedLine(line, trimmed, fenceMarker, segments) {
     segments.push(line);
     return isFenceClosure(trimmed, fenceMarker) ? null : fenceMarker;
 }
-function handleUnfencedLine(line, segments, buffer) {
+function handleUnfencedLine(line, segments, buffer, options) {
     const newMarker = checkFenceStart(line);
     if (!newMarker) {
         buffer.push(line);
         return { fenceMarker: null, buffer };
     }
     if (buffer.length > 0) {
-        segments.push(processTextBuffer(buffer));
+        segments.push(processTextBuffer(buffer, options));
         buffer = [];
     }
     segments.push(line);
     return { fenceMarker: newMarker, buffer };
 }
-export function cleanupMarkdownArtifacts(content) {
+export function cleanupMarkdownArtifacts(content, options) {
     if (!content)
         return '';
+    throwIfAborted(options?.signal, options?.url ?? '', 'markdown:cleanup:begin');
     const len = content.length;
     let lastIndex = 0;
     let fenceMarker = null;
@@ -279,12 +341,12 @@ export function cleanupMarkdownArtifacts(content) {
             fenceMarker = handleFencedLine(line, trimmed, fenceMarker, segments);
         }
         else {
-            ({ fenceMarker, buffer } = handleUnfencedLine(line, segments, buffer));
+            ({ fenceMarker, buffer } = handleUnfencedLine(line, segments, buffer, options));
         }
         lastIndex = nextIndex;
     }
     if (buffer.length > 0) {
-        segments.push(processTextBuffer(buffer));
+        segments.push(processTextBuffer(buffer, options));
     }
     return segments.join('\n').trim();
 }

package/dist/mcp-validator.d.ts

@@ -1,9 +1,9 @@
 export type JsonRpcId = string | number | null;
-export interface McpRequestParams {
+interface McpRequestParams {
     _meta?: Record<string, unknown>;
     [key: string]: unknown;
 }
-export interface McpRequestBody {
+interface McpRequestBody {
     jsonrpc: '2.0';
     method: string;
     id?: JsonRpcId;
@@ -13,3 +13,4 @@ export declare function isJsonRpcBatchRequest(body: unknown): boolean;
 export declare function isMcpRequestBody(body: unknown): body is McpRequestBody;
 export declare function acceptsEventStream(header: string | null | undefined): boolean;
 export declare function acceptsJsonAndEventStream(header: string | null | undefined): boolean;
+export {};

package/dist/mcp-validator.js

@@ -13,17 +13,16 @@ export function isJsonRpcBatchRequest(body) {
 export function isMcpRequestBody(body) {
     return mcpRequestSchema.safeParse(body).success;
 }
-export function acceptsEventStream(header) {
+function parseAcceptHeader(header) {
     if (!header)
-        return false;
-    return header
-        .split(',')
-        .some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
+        return [];
+    return header.split(',').map((value) => value.trim());
+}
+export function acceptsEventStream(header) {
+    return parseAcceptHeader(header).some((value) => value.trim().toLowerCase().startsWith('text/event-stream'));
 }
 function hasAcceptedMediaType(header, exact, wildcardPrefix) {
-    if (!header)
-        return false;
-    return header.split(',').some((rawPart) => {
+    return parseAcceptHeader(header).some((rawPart) => {
         const mediaType = rawPart.trim().split(';', 1)[0]?.trim().toLowerCase();
         if (!mediaType)
             return false;

package/dist/mcp.js

@@ -8,26 +8,35 @@ import { isObject } from './type-guards.js';
 /* -------------------------------------------------------------------------------------------------
  * Tasks API schemas
  * ------------------------------------------------------------------------------------------------- */
-const TaskGetSchema = z.strictObject({
+const TaskGetSchema = z
+    .object({
     method: z.literal('tasks/get'),
-    params: z.strictObject({ taskId: z.string() }),
-});
-const TaskListSchema = z.strictObject({
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
+const TaskListSchema = z
+    .object({
     method: z.literal('tasks/list'),
     params: z
-        .strictObject({
+        .object({
         cursor: z.string().optional(),
     })
+        .loose()
         .optional(),
-});
-const TaskCancelSchema = z.strictObject({
+})
+    .loose();
+const TaskCancelSchema = z
+    .object({
     method: z.literal('tasks/cancel'),
-    params: z.strictObject({ taskId: z.string() }),
-});
-const TaskResultSchema = z.strictObject({
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
+const TaskResultSchema = z
+    .object({
     method: z.literal('tasks/result'),
-    params: z.strictObject({ taskId: z.string() }),
-});
+    params: z.object({ taskId: z.string() }).loose(),
+})
+    .loose();
 const MIN_TASK_TTL_MS = 1_000;
 const MAX_TASK_TTL_MS = 86_400_000;
 const ExtendedCallToolRequestSchema = z
@@ -71,6 +80,14 @@ function parseExtendedCallToolRequest(request) {
 function isRecord(value) {
     return isObject(value);
 }
+function normalizeSendNotification(sendNotification) {
+    if (typeof sendNotification !== 'function')
+        return undefined;
+    const notify = sendNotification;
+    return async (notification) => {
+        await Promise.resolve(notify(notification));
+    };
+}
 function parseHandlerExtra(extra) {
     if (!isObject(extra))
         return undefined;
@@ -93,11 +110,9 @@ function parseHandlerExtra(extra) {
     if (typeof requestId === 'string' || typeof requestId === 'number') {
         parsed.requestId = requestId;
     }
-    if (typeof sendNotification === 'function') {
-        const notify = sendNotification;
-        parsed.sendNotification = async (notification) => {
-            await Promise.resolve(notify(notification));
-        };
+    const normalizedSendNotification = normalizeSendNotification(sendNotification);
+    if (normalizedSendNotification) {
+        parsed.sendNotification = normalizedSendNotification;
     }
     return parsed;
 }

package/dist/observability.d.ts

@@ -1,5 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export type LogMetadata = Record<string, unknown>;
+type LogMetadata = Record<string, unknown>;
 interface RequestContext {
     readonly requestId: string;
     readonly sessionId?: string;

package/dist/observability.js

@@ -128,6 +128,13 @@ function mapToMcpLevel(level) {
             return 'info';
     }
 }
+function resolveErrorText(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === 'string')
+        return err;
+    return 'unknown error';
+}
 function safeWriteStderr(line) {
     if (!stderrAvailable)
         return;
@@ -164,20 +171,14 @@ function writeLog(level, message, meta) {
             .catch((err) => {
             if (!isDebugEnabled())
                 return;
-            let errorText = 'unknown error';
-            if (err instanceof Error) {
-                errorText = err.message;
-            }
-            else if (typeof err === 'string') {
-                errorText = err;
-            }
+            const errorText = resolveErrorText(err);
             safeWriteStderr(`[${createTimestamp()}] WARN: Failed to forward log to MCP${sessionId ? ` (sessionId=${sessionId})` : ''}: ${errorText}\n`);
         });
     }
     catch (err) {
         if (!isDebugEnabled())
             return;
-        const errorText = err instanceof Error ? err.message : 'unknown error';
+        const errorText = resolveErrorText(err);
         safeWriteStderr(`[${createTimestamp()}] WARN: Failed to forward log to MCP (sync error): ${errorText}\n`);
     }
 }

package/dist/prompts.js

@@ -1,18 +1,10 @@
 export function registerGetHelpPrompt(server, instructions, iconInfo) {
     const description = 'Return the Fetch URL usage instructions.';
+    const iconConfig = iconInfo ? { icons: [{ ...iconInfo }] } : {};
     server.registerPrompt('get-help', {
         title: 'Get Help',
         description,
-        ...(iconInfo
-            ? {
-                icons: [
-                    {
-                        src: iconInfo.src,
-                        mimeType: iconInfo.mimeType,
-                    },
-                ],
-            }
-            : {}),
+        ...iconConfig,
     }, () => ({
         description,
         messages: [

package/dist/resources.js

@@ -21,17 +21,19 @@ function decodeSegment(value) {
         return value;
     }
 }
+function trimToValue(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 function firstVariableValue(value) {
     if (typeof value === 'string') {
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
+        return trimToValue(value);
     }
     if (Array.isArray(value)) {
         const first = value[0];
         if (typeof first !== 'string')
             return undefined;
-        const trimmed = first.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
+        return trimToValue(first);
     }
     return undefined;
 }

package/dist/server-tuning.d.ts

@@ -1,4 +1,4 @@
-export interface HttpServerTuningTarget {
+interface HttpServerTuningTarget {
     headersTimeout?: number;
     requestTimeout?: number;
     keepAliveTimeout?: number;
@@ -11,3 +11,4 @@ export interface HttpServerTuningTarget {
 }
 export declare function applyHttpServerTuning(server: HttpServerTuningTarget): void;
 export declare function drainConnectionsOnShutdown(server: HttpServerTuningTarget): void;
+export {};

package/dist/server-tuning.js

@@ -1,23 +1,28 @@
 import { config } from './config.js';
 import { logDebug, logWarn } from './observability.js';
 const DROP_LOG_INTERVAL_MS = 10_000;
+function setIfDefined(value, setter) {
+    if (value === undefined)
+        return;
+    setter(value);
+}
 export function applyHttpServerTuning(server) {
     const { headersTimeoutMs, requestTimeoutMs, keepAliveTimeoutMs, keepAliveTimeoutBufferMs, maxHeadersCount, maxConnections, } = config.server.http;
-    if (headersTimeoutMs !== undefined) {
-        server.headersTimeout = headersTimeoutMs;
-    }
-    if (requestTimeoutMs !== undefined) {
-        server.requestTimeout = requestTimeoutMs;
-    }
-    if (keepAliveTimeoutMs !== undefined) {
-        server.keepAliveTimeout = keepAliveTimeoutMs;
-    }
-    if (keepAliveTimeoutBufferMs !== undefined) {
-        server.keepAliveTimeoutBuffer = keepAliveTimeoutBufferMs;
-    }
-    if (maxHeadersCount !== undefined) {
-        server.maxHeadersCount = maxHeadersCount;
-    }
+    setIfDefined(headersTimeoutMs, (value) => {
+        server.headersTimeout = value;
+    });
+    setIfDefined(requestTimeoutMs, (value) => {
+        server.requestTimeout = value;
+    });
+    setIfDefined(keepAliveTimeoutMs, (value) => {
+        server.keepAliveTimeout = value;
+    });
+    setIfDefined(keepAliveTimeoutBufferMs, (value) => {
+        server.keepAliveTimeoutBuffer = value;
+    });
+    setIfDefined(maxHeadersCount, (value) => {
+        server.maxHeadersCount = value;
+    });
     if (typeof maxConnections === 'number' && maxConnections > 0) {
         server.maxConnections = maxConnections;
         if (typeof server.on === 'function') {

package/dist/server.js

@@ -70,6 +70,9 @@ function createServerInfo(icons) {
         ...(icons ? { icons } : {}),
     };
 }
+function toIconList(icon) {
+    return icon ? [icon] : undefined;
+}
 /* -------------------------------------------------------------------------------------------------
  * Server lifecycle
  * ------------------------------------------------------------------------------------------------- */
@@ -88,14 +91,7 @@ async function createMcpServerWithOptions(options) {
     if (serverInstructions) {
         serverConfig.instructions = serverInstructions;
     }
-    const serverInfo = createServerInfo(localIcon
-        ? [
-            {
-                src: localIcon.src,
-                mimeType: localIcon.mimeType,
-            },
-        ]
-        : undefined);
+    const serverInfo = createServerInfo(toIconList(localIcon));
     const server = new McpServer(serverInfo, serverConfig);
     if (options?.registerObservabilityServer ?? true) {
         setMcpServer(server);

package/dist/session.d.ts

@@ -21,12 +21,12 @@ export interface SessionStore {
     evictExpired: () => SessionEntry[];
     evictOldest: () => SessionEntry | undefined;
 }
-export interface SlotTracker {
+interface SlotTracker {
     readonly releaseSlot: () => void;
     readonly markInitialized: () => void;
     readonly isInitialized: () => boolean;
 }
-export type CloseHandler = (() => void) | undefined;
+type CloseHandler = (() => void) | undefined;
 export declare function composeCloseHandlers(first: CloseHandler, second: CloseHandler): CloseHandler;
 export declare function startSessionCleanupLoop(store: SessionStore, sessionTtlMs: number): AbortController;
 export declare function createSessionStore(sessionTtlMs: number): SessionStore;
@@ -37,3 +37,4 @@ export declare function ensureSessionCapacity({ store, maxSessions, evictOldest,
     maxSessions: number;
     evictOldest: (store: SessionStore) => boolean;
 }): boolean;
+export {};

package/dist/session.js

@@ -96,6 +96,9 @@ function moveSessionToEnd(sessions, sessionId, session) {
     sessions.delete(sessionId);
     sessions.set(sessionId, session);
 }
+function isBlankSessionId(sessionId) {
+    return sessionId.length === 0;
+}
 class InMemorySessionStore {
     sessionTtlMs;
     sessions = new Map();
@@ -104,12 +107,12 @@ class InMemorySessionStore {
         this.sessionTtlMs = sessionTtlMs;
     }
     get(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return undefined;
         return this.sessions.get(sessionId);
     }
     touch(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return;
         const session = this.sessions.get(sessionId);
         if (!session)
@@ -118,12 +121,12 @@ class InMemorySessionStore {
         moveSessionToEnd(this.sessions, sessionId, session);
     }
     set(sessionId, entry) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return;
         moveSessionToEnd(this.sessions, sessionId, entry);
     }
     remove(sessionId) {
-        if (!sessionId)
+        if (isBlankSessionId(sessionId))
             return undefined;
         const session = this.sessions.get(sessionId);
         this.sessions.delete(sessionId);

package/dist/tasks.d.ts

@@ -16,7 +16,7 @@ export interface TaskState {
     result?: unknown;
     error?: TaskError;
 }
-export interface CreateTaskOptions {
+interface CreateTaskOptions {
     ttl?: number;
 }
 export interface CreateTaskResult {

package/dist/tasks.js

@@ -41,7 +41,7 @@ class TaskManager {
     removeExpiredTasks() {
         const now = Date.now();
         for (const [id, task] of this.tasks) {
-            if (now - task._createdAtMs > task.ttl) {
+            if (this.isExpired(task, now)) {
                 this.tasks.delete(id);
             }
         }
@@ -146,7 +146,7 @@ class TaskManager {
         for (const task of this.tasks.values()) {
             if (task.ownerKey !== ownerKey)
                 continue;
-            if (now - task._createdAtMs > task.ttl) {
+            if (this.isExpired(task, now)) {
                 this.tasks.delete(task.taskId);
                 continue;
             }
@@ -284,8 +284,8 @@ class TaskManager {
         for (const waiter of waiters)
             waiter(task);
     }
-    isExpired(task) {
-        return Date.now() - task._createdAtMs > task.ttl;
+    isExpired(task, now = Date.now()) {
+        return now - task._createdAtMs > task.ttl;
     }
     encodeCursor(index) {
         return Buffer.from(String(index), 'utf8').toString('base64url');

package/dist/timer-utils.js

@@ -1,12 +1,15 @@
 import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
 import { isError } from './type-guards.js';
+function isAbortError(error) {
+    return isError(error) && error.name === 'AbortError';
+}
 export function createUnrefTimeout(timeoutMs, value) {
     const controller = new AbortController();
     const promise = setTimeoutPromise(timeoutMs, value, {
         ref: false,
         signal: controller.signal,
     }).catch((err) => {
-        if (isError(err) && err.name === 'AbortError') {
+        if (isAbortError(err)) {
             return new Promise(() => { });
         }
         throw err;