rehype-og-card 1.1.1 → 2.0.1

package/README.md

@@ -115,6 +115,14 @@ Path to save the build cache. For Astro projects, specify the `./node_modules/.a
 - Type: `string`
 - Default: `"./.cache/og-card"`
 
+### `buildCacheMaxAge`
+
+Cache expiration time for build cache in milliseconds. Set to `false` to disable expiration.
+Expiration is calculated using the cached timestamp stored in the cache itself.
+
+- Type: `number | false`
+- Default: `2592000000` (30 days)
+
 ### `crawlerUserAgent`
 
 User agent to use for fetching the OG metadata and images.
@@ -171,6 +179,14 @@ Path to save the server cache. Specify the directory whose contents will be copi
 - Type: `string`
 - Default: `"./public"`
 
+### `serverCacheMaxAge`
+
+Cache expiration time for server cache in milliseconds. Set to `false` to disable expiration.
+Expiration is calculated using the cached timestamp stored in the cache itself.
+
+- Type: `number | false`
+- Default: `2592000000` (30 days)
+
 ### `shortenURL`
 
 Whether to shorten the displayed URL.

package/dist/index.js

@@ -5,8 +5,13 @@ import { restoreBuildCache, restoreOGDataBuildCache, saveBuildCacheFile, saveOGD
 import { isElement } from "hast-util-is-element";
 import path from "path";
 import { visitParents } from "unist-util-visit-parents";
+// eslint-disable-next-line no-magic-numbers
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+// eslint-disable-next-line no-magic-numbers
+const DEFAULT_CACHE_MAX_AGE_MS = 30 * ONE_DAY_MS;
 const DEFAULT_OPTIONS = {
     buildCache: false,
+    buildCacheMaxAge: DEFAULT_CACHE_MAX_AGE_MS,
     buildCachePath: "./node_modules/.cache",
     crawlerUserAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
     decoding: "async",
@@ -15,6 +20,7 @@ const DEFAULT_OPTIONS = {
     loading: "lazy",
     openInNewTab: false,
     serverCache: true,
+    serverCacheMaxAge: DEFAULT_CACHE_MAX_AGE_MS,
     serverCachePath: "./public",
     shortenURL: true
 };
@@ -37,7 +43,7 @@ const rehypeOGCard = (options) => {
     const buildCacheExists = checkFileExistsSync(mergedOptions.buildCachePath);
     if (mergedOptions.buildCache) {
         if (buildCacheExists) {
-            restoreBuildCache(mergedOptions.buildCachePath, mergedOptions.serverCachePath);
+            restoreBuildCache(mergedOptions.buildCachePath, mergedOptions.serverCachePath, mergedOptions.buildCacheMaxAge);
         }
         else {
             createDirectorySync(mergedOptions.buildCachePath);
@@ -91,7 +97,7 @@ const rehypeOGCard = (options) => {
             // eslint-disable-next-line jsdoc/require-jsdoc, max-statements, max-lines-per-function
             const linkCardPromise = async () => {
                 let OGData = mergedOptions.buildCache
-                    ? await restoreOGDataBuildCache(anchorNode.properties.href, mergedOptions.buildCachePath)
+                    ? await restoreOGDataBuildCache(anchorNode.properties.href, mergedOptions.buildCachePath, mergedOptions.buildCacheMaxAge)
                     : null;
                 if (!OGData) {
                     OGData = await getOGData(anchorNode.properties.href, mergedOptions.crawlerUserAgent);
@@ -103,6 +109,7 @@ const rehypeOGCard = (options) => {
                 }
                 if (OGData.OGImageURL && mergedOptions.serverCache) {
                     const filename = await downloadImage({
+                        cacheMaxAge: mergedOptions.serverCacheMaxAge,
                         directory: mergedOptions.serverCachePath,
                         url: OGData.OGImageURL,
                         userAgent: mergedOptions.crawlerUserAgent
@@ -118,6 +125,7 @@ const rehypeOGCard = (options) => {
                 }
                 if (OGData.faviconURL && mergedOptions.serverCache) {
                     const filename = await downloadImage({
+                        cacheMaxAge: mergedOptions.serverCacheMaxAge,
                         directory: mergedOptions.serverCachePath,
                         url: OGData.faviconURL,
                         userAgent: mergedOptions.crawlerUserAgent

package/dist/types.d.ts

@@ -41,6 +41,13 @@ interface RehypeOGCardOptions {
      * @default "./public"
      */
     serverCachePath?: string;
+    /**
+     * Cache expiration time for server cache in milliseconds.
+     * Set to `false` to disable expiration.
+     * Expiration is calculated from the cached timestamp stored in the cache itself.
+     * @default 2592000000
+     */
+    serverCacheMaxAge?: number | false;
     /**
      * Whether to cache the OG metadata and images for the next build.
      * `buildCache` option requires `serverCache` option to be enabled.
@@ -53,6 +60,13 @@ interface RehypeOGCardOptions {
      * @default "./node_modules/.cache"
      */
     buildCachePath?: string;
+    /**
+     * Cache expiration time for build cache in milliseconds.
+     * Set to `false` to disable expiration.
+     * Expiration is calculated from the cached timestamp stored in the cache itself.
+     * @default 2592000000
+     */
+    buildCacheMaxAge?: number | false;
     /**
      * User agent to use for fetching the OG metadata and images.
      * @default "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
@@ -70,4 +84,10 @@ interface OGCardData {
     OGImageWidth?: number | undefined;
     OGImageHeight?: number | undefined;
 }
-export type { RehypeOGCardOptions, OGCardData };
+declare const cacheIndexSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    [x: string]: {
+        createdAt: number;
+    };
+}, {}>;
+type CacheIndex = typeof cacheIndexSchema.infer;
+export { cacheIndexSchema, type RehypeOGCardOptions, type OGCardData, type CacheIndex };

package/dist/types.js

@@ -1 +1,7 @@
-export {};
+import { type } from "arktype";
+const cacheIndexSchema = type({
+    "[string]": {
+        createdAt: "number"
+    }
+});
+export { cacheIndexSchema };

package/dist/util/cache.d.ts

@@ -1,4 +1,29 @@
-import type { OGCardData } from "../types.js";
+import { type CacheIndex, type OGCardData } from "../types.js";
+/**
+ * Check whether a cache entry is expired.
+ * @param cachedAtMs Cached timestamp in milliseconds.
+ * @param maxAgeMs Cache expiration time in milliseconds.
+ * @returns `true` if expired, otherwise `false`.
+ */
+declare const isCacheExpired: (cachedAtMs: number, maxAgeMs: number | false) => boolean;
+/**
+ * Get the cache index path for a directory.
+ * @param directory Cache directory path.
+ * @returns Cache index path.
+ */
+declare const getCacheIndexPath: (directory: string) => string;
+/**
+ * Read cache index.
+ * @param directory Cache directory path.
+ * @returns Cache index data.
+ */
+declare const readCacheIndex: (directory: string) => Promise<CacheIndex>;
+/**
+ * Write cache index.
+ * @param directory Cache directory path.
+ * @param index Cache index data.
+ */
+declare const writeCacheIndex: (directory: string, index: CacheIndex) => Promise<void>;
 /**
  * Save build cache if server cache exists.
  * @param serverCachePath Server cache path.
@@ -9,8 +34,9 @@ declare const saveBuildCacheFile: (serverCachePath: string, buildCachePath: stri
  * Restore build cache if it exists.
  * @param buildCachePath Build cache path.
  * @param serverCachePath Server cache path.
+ * @param maxAgeMs Cache expiration time in milliseconds.
  */
-declare const restoreBuildCache: (buildCachePath: string, serverCachePath: string) => void;
+declare const restoreBuildCache: (buildCachePath: string, serverCachePath: string, maxAgeMs: number | false) => void;
 /**
  * Save OG data to build cache.
  * @param url URL of the OG data.
@@ -22,7 +48,8 @@ declare const saveOGDataBuildCache: (url: string, OGData: OGCardData, buildCache
  * Restore OG data from build cache.
  * @param url URL of the OG data.
  * @param buildCachePath Build cache path.
+ * @param maxAgeMs Cache expiration time in milliseconds.
  * @returns Restored OG data. If not found, returns `null`.
  */
-declare const restoreOGDataBuildCache: (url: string, buildCachePath: string) => Promise<OGCardData | null>;
-export { saveBuildCacheFile, restoreBuildCache, saveOGDataBuildCache, restoreOGDataBuildCache };
+declare const restoreOGDataBuildCache: (url: string, buildCachePath: string, maxAgeMs: number | false) => Promise<OGCardData | null>;
+export { getCacheIndexPath, isCacheExpired, readCacheIndex, restoreBuildCache, restoreOGDataBuildCache, saveBuildCacheFile, saveOGDataBuildCache, writeCacheIndex };

package/dist/util/cache.js

@@ -1,25 +1,296 @@
-import { checkFileExists, copyDirectory, generateFilename } from "./file.js";
+/* eslint-disable max-lines */
+import { cacheIndexSchema } from "../types.js";
+import { checkFileExists, generateFilename } from "./file.js";
 import fs from "fs/promises";
+import fsSync from "fs";
 import path from "path";
+import { setTimeout } from "timers/promises";
+import { type } from "arktype";
+/**
+ * Check whether a cache entry is expired.
+ * @param cachedAtMs Cached timestamp in milliseconds.
+ * @param maxAgeMs Cache expiration time in milliseconds.
+ * @returns `true` if expired, otherwise `false`.
+ */
+const isCacheExpired = (cachedAtMs, maxAgeMs) => {
+    if (maxAgeMs === false)
+        return false;
+    return Date.now() - cachedAtMs > maxAgeMs;
+};
+const CACHE_INDEX_FILENAME = "cache.json";
+const CACHE_INDEX_LOCK_FILENAME = "cache.json.lock";
+/**
+ * Get the cache index path for a directory.
+ * @param directory Cache directory path.
+ * @returns Cache index path.
+ */
+const getCacheIndexPath = (directory) => path.join(directory, CACHE_INDEX_FILENAME);
+/**
+ * Get the cache index lock path for a directory.
+ * @param directory Cache directory path.
+ * @returns Cache index lock path.
+ */
+const getCacheIndexLockPath = (directory) => path.join(directory, CACHE_INDEX_LOCK_FILENAME);
+/**
+ * Sleep synchronously for a given duration.
+ * @param ms Duration in milliseconds.
+ */
+const sleepSync = (ms) => {
+    // eslint-disable-next-line no-magic-numbers
+    const buffer = new SharedArrayBuffer(4);
+    const view = new Int32Array(buffer);
+    // eslint-disable-next-line no-magic-numbers
+    Atomics.wait(view, 0, 0, ms);
+};
+/**
+ * Acquire the cache index lock.
+ * @param directory Cache directory path.
+ * @returns Release function or `null` if locking failed.
+ */
+const acquireCacheIndexLock = async (directory) => {
+    const lockPath = getCacheIndexLockPath(directory);
+    const maxRetries = 50;
+    const delayMs = 20;
+    const firstAttempt = 0;
+    const nextAttemptIncrement = 1;
+    /**
+     * Try acquiring the cache index lock.
+     * @param attempt Current attempt count.
+     * @returns Release function or `null` if locking failed.
+     */
+    const tryAcquire = async (attempt) => {
+        try {
+            const handle = await fs.open(lockPath, "wx");
+            await handle.close();
+            return async () => {
+                await fs.rm(lockPath, { force: true });
+            };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST")
+                throw error;
+            if (attempt >= maxRetries)
+                return null;
+            await setTimeout(delayMs);
+            return tryAcquire(attempt + nextAttemptIncrement);
+        }
+    };
+    return tryAcquire(firstAttempt);
+};
+/**
+ * Acquire the cache index lock synchronously.
+ * @param directory Cache directory path.
+ * @returns Release function or `null` if locking failed.
+ */
+const acquireCacheIndexLockSync = (directory) => {
+    const lockPath = getCacheIndexLockPath(directory);
+    const maxRetries = 50;
+    const delayMs = 20;
+    const firstAttempt = 0;
+    const nextAttemptIncrement = 1;
+    /**
+     * Try acquiring the cache index lock synchronously.
+     * @param attempt Current attempt count.
+     * @returns Release function or `null` if locking failed.
+     */
+    const tryAcquire = (attempt) => {
+        try {
+            const fd = fsSync.openSync(lockPath, "wx");
+            fsSync.closeSync(fd);
+            return () => {
+                fsSync.rmSync(lockPath, { force: true });
+            };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST")
+                throw error;
+            if (attempt >= maxRetries)
+                return null;
+            sleepSync(delayMs);
+            return tryAcquire(attempt + nextAttemptIncrement);
+        }
+    };
+    return tryAcquire(firstAttempt);
+};
+/**
+ * Read cache index synchronously.
+ * @param directory Cache directory path.
+ * @returns Cache index data.
+ */
+const readCacheIndexSync = (directory) => {
+    const indexPath = getCacheIndexPath(directory);
+    try {
+        const raw = fsSync.readFileSync(indexPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const validated = cacheIndexSchema(parsed);
+        if (validated instanceof type.errors)
+            return {};
+        return validated;
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Write cache index synchronously.
+ * @param directory Cache directory path.
+ * @param index Cache index data.
+ */
+const writeCacheIndexSync = (directory, index) => {
+    const indexPath = getCacheIndexPath(directory);
+    const tempPath = `${indexPath}.tmp`;
+    const releaseLock = acquireCacheIndexLockSync(directory);
+    try {
+        fsSync.writeFileSync(tempPath, JSON.stringify(index));
+        fsSync.renameSync(tempPath, indexPath);
+    }
+    finally {
+        releaseLock?.();
+    }
+};
+/**
+ * Read cache index.
+ * @param directory Cache directory path.
+ * @returns Cache index data.
+ */
+const readCacheIndex = async (directory) => {
+    const indexPath = getCacheIndexPath(directory);
+    const exists = await checkFileExists(indexPath);
+    if (!exists)
+        return {};
+    try {
+        const raw = await fs.readFile(indexPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const validated = cacheIndexSchema(parsed);
+        if (validated instanceof type.errors)
+            return {};
+        return validated;
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Write cache index.
+ * @param directory Cache directory path.
+ * @param index Cache index data.
+ */
+const writeCacheIndex = async (directory, index) => {
+    const indexPath = getCacheIndexPath(directory);
+    const tempPath = `${indexPath}.tmp`;
+    const releaseLock = await acquireCacheIndexLock(directory);
+    try {
+        await fs.writeFile(tempPath, JSON.stringify(index));
+        await fs.rename(tempPath, indexPath);
+    }
+    finally {
+        await releaseLock?.();
+    }
+};
+/**
+ * Remove a cache file synchronously.
+ * @param directory Cache directory path.
+ * @param filename Cache filename.
+ */
+const removeCacheEntrySync = (directory, filename) => {
+    const filePath = path.join(directory, filename);
+    fsSync.rmSync(filePath, { force: true });
+};
+/**
+ * Remove expired cache files synchronously.
+ * @param directory Cache directory path.
+ * @param maxAgeMs Cache expiration time in milliseconds.
+ */
+// eslint-disable-next-line max-statements, max-lines-per-function
+const pruneExpiredCacheFilesSync = (directory, maxAgeMs) => {
+    if (maxAgeMs === false)
+        return;
+    if (!fsSync.existsSync(directory))
+        return;
+    const index = readCacheIndexSync(directory);
+    let indexUpdated = false;
+    const entries = fsSync.readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            pruneExpiredCacheFilesSync(entryPath, maxAgeMs);
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        // eslint-disable-next-line no-continue
+        if (entry.name === CACHE_INDEX_FILENAME || entry.name === CACHE_INDEX_LOCK_FILENAME)
+            continue;
+        if (entry.name.endsWith(".json")) {
+            try {
+                const raw = fsSync.readFileSync(entryPath, "utf-8");
+                const data = JSON.parse(raw);
+                if (typeof data.cachedAt !== "number") {
+                    fsSync.rmSync(entryPath, { force: true });
+                    // eslint-disable-next-line no-continue
+                    continue;
+                }
+                if (isCacheExpired(data.cachedAt, maxAgeMs)) {
+                    fsSync.rmSync(entryPath, { force: true });
+                }
+            }
+            catch {
+                fsSync.rmSync(entryPath, { force: true });
+            }
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const cachedAtMs = index[entry.name]?.createdAt;
+        if (typeof cachedAtMs !== "number" || isCacheExpired(cachedAtMs, maxAgeMs)) {
+            removeCacheEntrySync(directory, entry.name);
+            indexUpdated = true;
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete index[entry.name];
+        }
+    }
+    if (indexUpdated) {
+        writeCacheIndexSync(directory, index);
+    }
+};
 /**
  * Save build cache if server cache exists.
  * @param serverCachePath Server cache path.
  * @param buildCachePath Build cache path.
  */
+// eslint-disable-next-line max-statements
 const saveBuildCacheFile = async (serverCachePath, buildCachePath) => {
     const serverCacheExists = await checkFileExists(serverCachePath);
     const buildCacheExists = await checkFileExists(buildCachePath);
     if (serverCacheExists && !buildCacheExists) {
         await fs.copyFile(serverCachePath, buildCachePath);
     }
+    const buildCacheExistsAfter = await checkFileExists(buildCachePath);
+    if (!buildCacheExistsAfter)
+        return;
+    const serverDirectory = path.dirname(serverCachePath);
+    const buildDirectory = path.dirname(buildCachePath);
+    const filename = path.basename(buildCachePath);
+    const serverIndex = readCacheIndexSync(serverDirectory);
+    const cachedAt = typeof serverIndex[filename]?.createdAt === "number" ? serverIndex[filename].createdAt : Date.now();
+    const buildIndex = readCacheIndexSync(buildDirectory);
+    buildIndex[filename] = { createdAt: cachedAt };
+    writeCacheIndexSync(buildDirectory, buildIndex);
 };
 /**
  * Restore build cache if it exists.
  * @param buildCachePath Build cache path.
  * @param serverCachePath Server cache path.
+ * @param maxAgeMs Cache expiration time in milliseconds.
  */
-const restoreBuildCache = (buildCachePath, serverCachePath) => {
-    copyDirectory(buildCachePath, serverCachePath);
+const restoreBuildCache = (buildCachePath, serverCachePath, maxAgeMs) => {
+    if (!fsSync.existsSync(buildCachePath))
+        return;
+    pruneExpiredCacheFilesSync(buildCachePath, maxAgeMs);
+    if (!fsSync.existsSync(serverCachePath)) {
+        fsSync.mkdirSync(serverCachePath, { recursive: true });
+    }
+    fsSync.cpSync(buildCachePath, serverCachePath, { recursive: true });
 };
 /**
  * Save OG data to build cache.
@@ -34,23 +305,42 @@ const saveOGDataBuildCache = async (url, OGData, buildCachePath) => {
     if (!cacheDirectoryExists) {
         await fs.mkdir(buildCachePath, { recursive: true });
     }
-    await fs.writeFile(savePath, JSON.stringify(OGData));
+    const payload = { ...OGData, cachedAt: Date.now() };
+    await fs.writeFile(savePath, JSON.stringify(payload));
 };
 /**
  * Restore OG data from build cache.
  * @param url URL of the OG data.
  * @param buildCachePath Build cache path.
+ * @param maxAgeMs Cache expiration time in milliseconds.
  * @returns Restored OG data. If not found, returns `null`.
  */
-const restoreOGDataBuildCache = async (url, buildCachePath) => {
+// eslint-disable-next-line max-statements
+const restoreOGDataBuildCache = async (url, buildCachePath, maxAgeMs) => {
     const filename = generateFilename(url, false);
     const savePath = `${path.join(buildCachePath, filename)}.json`;
     try {
         const data = await fs.readFile(savePath, "utf-8");
-        return JSON.parse(data);
+        const parsed = JSON.parse(data);
+        if (typeof parsed.cachedAt !== "number") {
+            if (maxAgeMs === false) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { cachedAt: __, ...rest } = parsed;
+                return rest;
+            }
+            await fs.rm(savePath, { force: true });
+            return null;
+        }
+        if (isCacheExpired(parsed.cachedAt, maxAgeMs)) {
+            await fs.rm(savePath, { force: true });
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { cachedAt: __, ...rest } = parsed;
+        return rest;
     }
     catch {
         return null;
     }
 };
-export { saveBuildCacheFile, restoreBuildCache, saveOGDataBuildCache, restoreOGDataBuildCache };
+export { getCacheIndexPath, isCacheExpired, readCacheIndex, restoreBuildCache, restoreOGDataBuildCache, saveBuildCacheFile, saveOGDataBuildCache, writeCacheIndex };

package/dist/util/network.d.ts

@@ -25,6 +25,11 @@ interface DownloadImageOptions {
      * User agent to use for fetching the image.
      */
     userAgent: string;
+    /**
+     * Cache expiration time in milliseconds.
+     * Set to `false` to disable expiration.
+     */
+    cacheMaxAge: number | false;
 }
 /**
  * Download image from given URL. If the image already exists, return the filename.

package/dist/util/network.js

@@ -1,4 +1,5 @@
 import { checkFileExists, generateFilename } from "./file.js";
+import { isCacheExpired, readCacheIndex, writeCacheIndex } from "./cache.js";
 import fetch from "node-fetch";
 import fs from "fs/promises";
 import path from "path";
@@ -73,7 +74,7 @@ const getOGData = async (url, userAgent) => {
  * @param options Options to download image.
  * @returns Filename of the downloaded image.
  */
-// eslint-disable-next-line max-statements
+// eslint-disable-next-line max-statements, max-lines-per-function
 const downloadImage = async (options) => {
     if (!isValidURL(options.url)) {
         // eslint-disable-next-line no-console
@@ -85,8 +86,22 @@ const downloadImage = async (options) => {
         const savePath = path.posix.join(options.directory, filename);
         // If the file already exists, return the filename.
         const fileExists = await checkFileExists(savePath);
-        if (fileExists)
-            return filename;
+        if (fileExists) {
+            if (options.cacheMaxAge === false)
+                return filename;
+            const index = await readCacheIndex(options.directory);
+            const entry = index[filename];
+            const cachedAt = entry?.createdAt;
+            const maxAge = options.cacheMaxAge;
+            if (typeof cachedAt === "number" && !isCacheExpired(cachedAt, maxAge))
+                return filename;
+            if (typeof entry !== "undefined") {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete index[filename];
+                await writeCacheIndex(options.directory, index);
+            }
+            await fs.rm(savePath, { force: true });
+        }
         const response = await fetch(options.url, {
             headers: {
                 "user-agent": options.userAgent
@@ -101,6 +116,10 @@ const downloadImage = async (options) => {
             await fs.mkdir(options.directory, { recursive: true });
         }
         await fs.writeFile(savePath, buffer);
+        const cachedAt = Date.now();
+        const index = await readCacheIndex(options.directory);
+        index[filename] = { createdAt: cachedAt };
+        await writeCacheIndex(options.directory, index);
         return filename;
     }
     catch (error) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "rehype-og-card",
-  "version": "1.1.1",
+  "version": "2.0.1",
   "description": "Rehype plugin to convert text links to link cards",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "./dist"
+    "dist"
   ],
   "type": "module",
   "publishConfig": {
@@ -43,8 +43,8 @@
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.7",
     "@robot-inventor/eslint-config": "^11.0.0",
-    "@robot-inventor/tsconfig-base": "^6.0.0",
-    "@types/node": "^24.2.1",
+    "@robot-inventor/tsconfig-base": "^7.0.0",
+    "@types/node": "^25.0.2",
     "eslint": "^9.7.0",
     "hast-util-to-html": "^9.0.1",
     "prettier": "^3.3.3",
@@ -57,6 +57,7 @@
   },
   "dependencies": {
     "@types/hast": "^3.0.4",
+    "arktype": "^2.1.29",
     "hast-util-is-element": "^3.0.0",
     "hastscript": "^9.0.0",
     "node-fetch": "^3.3.2",