@tsdoctor/snapshot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @tsdoctor/snapshot
+
+[![npm](https://img.shields.io/npm/v/@tsdoctor%2Fsnapshot?label=npm&color=cb3837)](https://www.npmjs.com/package/@tsdoctor/snapshot)
+[![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
+[![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+
+Incremental-build snapshot tracking for static documentation pipelines. The package stores per-file content hashes and timestamps in a schema-versioned SQLite database (built on `@effected/store`'s `Store`), so a build can skip writes for unchanged files, preserve SEO-critical publication timestamps, and clean up files that fell out of the source model.
+
+## What you get
+
+- **`SnapshotService`** — an Effect service tag with typed operations: single and bulk lookup, transactional batch upsert (with a conditional `ON CONFLICT ... DO UPDATE ... WHERE` that avoids rewriting unchanged rows), deletion and stale-entry cleanup.
+- **`SnapshotServiceLive(dbPath)`** — the live layer over a SQLite file. Layer construction applies migrations through `@effected/store`'s ledger; a WAL checkpoint runs as a scope finalizer on clean shutdown.
+- **`hashContent` / `hashFrontmatter` / `normalizeContent`** — pure SHA-256 helpers that normalize markdown bodies and frontmatter (excluding timestamp fields) into stable change-detection hashes.
+- **`FileSnapshot`** / **`SnapshotDbError`** — the tracked-file record and the typed error every operation can fail with.
+
+## Install
+
+```bash
+npm install @tsdoctor/snapshot
+# or
+pnpm add @tsdoctor/snapshot
+```
+
+This is an ESM-only package. `effect` (v4) and `@effected/store` are peer dependencies.
+
+## Quick start
+
+```ts
+import { SnapshotService, SnapshotServiceLive, hashContent } from "@tsdoctor/snapshot";
+import { Effect } from "effect";
+
+const layer = SnapshotServiceLive(".api-docs/snapshot/api-docs.db");
+
+const program = Effect.gen(function* () {
+  const snapshots = yield* SnapshotService;
+  const existing = yield* snapshots.getAllForDirectory("docs/api");
+  // ... compare hashContent(body) against existing entries, then:
+  yield* snapshots.batchUpsert(changed);
+  yield* snapshots.cleanupStale("docs/api", generatedFiles);
+});
+
+await Effect.runPromise(Effect.scoped(program.pipe(Effect.provide(layer))));
+```
+
+The parent directory of the database path must exist before the layer is built; path policy (where the database lives) is the caller's concern.
+
+## Provenance
+
+Extracted in phase 2 of the tsdoctor consolidation from the snapshot tracking system inside `rspress-plugin-api-extractor`, rebuilt on `@effected/store` with the same SQL schema and query semantics.
+
+## License
+
+[MIT](LICENSE)

package/SnapshotService.js

@@ -0,0 +1,27 @@
+import { Context, Data } from "effect";
+
+//#region src/SnapshotService.ts
+/**
+* Raised when a snapshot database operation fails.
+*
+* @public
+*/
+var SnapshotDbError = class extends Data.TaggedError("SnapshotDbError") {
+	/** Formatted failure message combining operation, path and reason. */
+	get message() {
+		return `Snapshot DB error during '${this.operation}' at '${this.dbPath}': ${this.reason}`;
+	}
+};
+/**
+* Effect service tag for the snapshot tracking store.
+*
+* @remarks
+* Provided by {@link SnapshotServiceLive}, which backs it with a
+* schema-versioned SQLite database via `@effected/store`.
+*
+* @public
+*/
+var SnapshotService = class extends Context.Service()("@tsdoctor/snapshot/SnapshotService") {};
+
+//#endregion
+export { SnapshotDbError, SnapshotService };

package/SnapshotServiceLive.js

@@ -0,0 +1,131 @@
+import { hashContent } from "./content-hash.js";
+import { SnapshotDbError, SnapshotService } from "./SnapshotService.js";
+import { Effect, Layer, Option } from "effect";
+import { Store } from "@effected/store";
+
+//#region src/SnapshotServiceLive.ts
+function toFileSnapshot(row) {
+	return {
+		outputDir: row.output_dir,
+		filePath: row.file_path,
+		publishedTime: row.published_time,
+		modifiedTime: row.modified_time,
+		contentHash: row.content_hash,
+		frontmatterHash: row.frontmatter_hash,
+		buildTime: row.build_time
+	};
+}
+function toSnapshotDbError(error) {
+	return new SnapshotDbError({
+		operation: "query",
+		dbPath: "snapshot-db",
+		reason: error instanceof Error ? error.message : String(error)
+	});
+}
+const migrations = [{
+	id: 1,
+	name: "001_create_snapshots",
+	up: (sql) => Effect.gen(function* () {
+		yield* sql`
+					CREATE TABLE IF NOT EXISTS file_snapshots (
+						id INTEGER PRIMARY KEY AUTOINCREMENT,
+						output_dir TEXT NOT NULL,
+						file_path TEXT NOT NULL,
+						published_time TEXT NOT NULL,
+						modified_time TEXT NOT NULL,
+						content_hash TEXT NOT NULL,
+						frontmatter_hash TEXT NOT NULL,
+						build_time TEXT NOT NULL,
+						UNIQUE(output_dir, file_path)
+					)
+				`;
+		yield* sql`CREATE INDEX IF NOT EXISTS idx_output_dir ON file_snapshots(output_dir)`;
+		yield* sql`CREATE INDEX IF NOT EXISTS idx_file_path ON file_snapshots(file_path)`;
+	})
+}];
+/**
+* Builds the live {@link SnapshotService} layer over a SQLite database file.
+*
+* @remarks
+* Backed by `@effected/store`'s `Store.layerSqlite`: layer construction opens
+* the database (WAL mode), ensures the migration ledger and applies pending
+* migrations. A WAL checkpoint (`PRAGMA wal_checkpoint(TRUNCATE)`) is
+* registered as a scope finalizer so the sidecar files are folded back into
+* the main database on clean shutdown.
+*
+* This is a parameterized layer factory: call it once per database path and
+* bind the result to a `const` — layers memoize by reference, and a fresh
+* call at each provide site would open the database more than once. The
+* parent directory of `dbPath` must already exist.
+*
+* @param dbPath - Path to the SQLite database file
+* @returns A layer providing {@link SnapshotService}
+* @public
+*/
+const SnapshotServiceLive = (dbPath) => {
+	const StoreLive = Store.layerSqlite({
+		filename: dbPath,
+		migrations
+	});
+	const ServiceImpl = Layer.effect(SnapshotService, Effect.gen(function* () {
+		const sql = (yield* Store).client;
+		yield* Effect.addFinalizer(() => sql`PRAGMA wal_checkpoint(TRUNCATE)`.pipe(Effect.ignore));
+		return {
+			hashContent,
+			getSnapshot: (outputDir, filePath) => sql`SELECT * FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${filePath}`.pipe(Effect.map((rows) => rows.length > 0 ? Option.some(toFileSnapshot(rows[0])) : Option.none()), Effect.mapError(toSnapshotDbError)),
+			getAllForDirectory: (outputDir) => sql`SELECT * FROM file_snapshots WHERE output_dir = ${outputDir}`.pipe(Effect.map((rows) => rows.map(toFileSnapshot)), Effect.mapError(toSnapshotDbError)),
+			getFilePaths: (outputDir) => sql`SELECT file_path FROM file_snapshots WHERE output_dir = ${outputDir}`.pipe(Effect.map((rows) => rows.map((r) => r.file_path)), Effect.mapError(toSnapshotDbError)),
+			upsert: (snapshot) => sql`INSERT INTO file_snapshots
+						(output_dir, file_path, published_time, modified_time,
+						 content_hash, frontmatter_hash, build_time)
+						VALUES (${snapshot.outputDir}, ${snapshot.filePath},
+								${snapshot.publishedTime}, ${snapshot.modifiedTime},
+								${snapshot.contentHash}, ${snapshot.frontmatterHash},
+								${snapshot.buildTime})
+						ON CONFLICT(output_dir, file_path) DO UPDATE SET
+							published_time = ${snapshot.publishedTime},
+							modified_time = ${snapshot.modifiedTime},
+							content_hash = ${snapshot.contentHash},
+							frontmatter_hash = ${snapshot.frontmatterHash},
+							build_time = ${snapshot.buildTime}
+						WHERE published_time != ${snapshot.publishedTime}
+						   OR modified_time != ${snapshot.modifiedTime}
+						   OR content_hash != ${snapshot.contentHash}
+						   OR frontmatter_hash != ${snapshot.frontmatterHash}`.pipe(Effect.as(true), Effect.mapError(toSnapshotDbError)),
+			batchUpsert: (snapshots) => (snapshots.length === 0 ? Effect.succeed(0) : sql.withTransaction(Effect.forEach(snapshots, (s) => sql`INSERT INTO file_snapshots
+												(output_dir, file_path, published_time, modified_time,
+												 content_hash, frontmatter_hash, build_time)
+												VALUES (${s.outputDir}, ${s.filePath},
+														${s.publishedTime}, ${s.modifiedTime},
+														${s.contentHash}, ${s.frontmatterHash},
+														${s.buildTime})
+												ON CONFLICT(output_dir, file_path) DO UPDATE SET
+													published_time = ${s.publishedTime},
+													modified_time = ${s.modifiedTime},
+													content_hash = ${s.contentHash},
+													frontmatter_hash = ${s.frontmatterHash},
+													build_time = ${s.buildTime}
+												WHERE published_time != ${s.publishedTime}
+												   OR modified_time != ${s.modifiedTime}
+												   OR content_hash != ${s.contentHash}
+												   OR frontmatter_hash != ${s.frontmatterHash}`, { concurrency: 1 })).pipe(Effect.map(() => snapshots.length))).pipe(Effect.mapError(toSnapshotDbError)),
+			deleteSnapshot: (outputDir, filePath) => sql`DELETE FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${filePath}`.pipe(Effect.asVoid, Effect.mapError(toSnapshotDbError)),
+			cleanupStale: (outputDir, currentFiles) => Effect.gen(function* () {
+				const rows = yield* sql`SELECT file_path FROM file_snapshots WHERE output_dir = ${outputDir}`;
+				const staleFiles = [];
+				for (const row of rows) {
+					const fp = row.file_path;
+					if (!currentFiles.has(fp)) {
+						yield* sql`DELETE FROM file_snapshots WHERE output_dir = ${outputDir} AND file_path = ${fp}`;
+						staleFiles.push(fp);
+					}
+				}
+				return staleFiles;
+			}).pipe(Effect.mapError(toSnapshotDbError))
+		};
+	}));
+	return Layer.provide(ServiceImpl, StoreLive);
+};
+
+//#endregion
+export { SnapshotServiceLive };

package/content-hash.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+
+//#region src/content-hash.ts
+/**
+* Normalizes content string for consistent hashing.
+*
+* @remarks
+* Applies the following transformations:
+* - Converts all line endings to Unix-style (`\n`)
+* - Trims leading and trailing whitespace
+* - Collapses multiple consecutive blank lines to a single blank line
+*
+* @param content - The content string to normalize
+* @returns Normalized content string
+*
+* @example
+* ```typescript
+* import { normalizeContent } from "@tsdoctor/snapshot";
+*
+* const normalized = normalizeContent("line1\r\n\r\n\r\nline2  ");
+* // => "line1\n\nline2"
+* ```
+*
+* @public
+*/
+function normalizeContent(content) {
+	return content.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim().replaceAll(/\n{3,}/g, "\n\n");
+}
+/**
+* Generates a SHA-256 hash of normalized markdown content.
+*
+* @remarks
+* The content is normalized before hashing to ensure consistent results
+* regardless of line ending differences or trailing whitespace.
+*
+* @param content - The markdown content to hash (excluding frontmatter)
+* @returns Hexadecimal SHA-256 hash string
+*
+* @example
+* ```typescript
+* import { hashContent } from "@tsdoctor/snapshot";
+*
+* const hash = hashContent("# My Title\n\nContent here");
+* ```
+*
+* @public
+*/
+function hashContent(content) {
+	const normalized = normalizeContent(content);
+	return createHash("sha256").update(normalized).digest("hex");
+}
+/**
+* Generates a SHA-256 hash of frontmatter fields.
+*
+* @remarks
+* Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
+* `article:published_time`, `article:modified_time`) to prevent circular
+* dependencies in change detection. Keys are sorted alphabetically before
+* hashing to ensure consistent results regardless of object key order.
+*
+* @param frontmatter - The frontmatter object to hash
+* @returns Hexadecimal SHA-256 hash string
+*
+* @example
+* ```typescript
+* import { hashFrontmatter } from "@tsdoctor/snapshot";
+*
+* const hash = hashFrontmatter({
+*   title: "My Page",
+*   description: "Page description"
+* });
+* ```
+*
+* @public
+*/
+function hashFrontmatter(frontmatter) {
+	const filtered = {};
+	for (const [key, value] of Object.entries(frontmatter)) {
+		if (key === "publishedTime" || key === "modifiedTime" || key === "head" || key === "article:published_time" || key === "article:modified_time") continue;
+		filtered[key] = value;
+	}
+	const sorted = Object.keys(filtered).sort().reduce((acc, key) => {
+		acc[key] = filtered[key];
+		return acc;
+	}, {});
+	const json = JSON.stringify(sorted);
+	return createHash("sha256").update(json).digest("hex");
+}
+
+//#endregion
+export { hashContent, hashFrontmatter, normalizeContent };

package/index.d.ts

@@ -0,0 +1,176 @@
+import { Context, Effect, Layer, Option } from "effect";
+import { StoreError, StoreMigrationError } from "@effected/store";
+//#region src/content-hash.d.ts
+/**
+ * Normalizes content string for consistent hashing.
+ *
+ * @remarks
+ * Applies the following transformations:
+ * - Converts all line endings to Unix-style (`\n`)
+ * - Trims leading and trailing whitespace
+ * - Collapses multiple consecutive blank lines to a single blank line
+ *
+ * @param content - The content string to normalize
+ * @returns Normalized content string
+ *
+ * @example
+ * ```typescript
+ * import { normalizeContent } from "@tsdoctor/snapshot";
+ *
+ * const normalized = normalizeContent("line1\r\n\r\n\r\nline2  ");
+ * // => "line1\n\nline2"
+ * ```
+ *
+ * @public
+ */
+declare function normalizeContent(content: string): string;
+/**
+ * Generates a SHA-256 hash of normalized markdown content.
+ *
+ * @remarks
+ * The content is normalized before hashing to ensure consistent results
+ * regardless of line ending differences or trailing whitespace.
+ *
+ * @param content - The markdown content to hash (excluding frontmatter)
+ * @returns Hexadecimal SHA-256 hash string
+ *
+ * @example
+ * ```typescript
+ * import { hashContent } from "@tsdoctor/snapshot";
+ *
+ * const hash = hashContent("# My Title\n\nContent here");
+ * ```
+ *
+ * @public
+ */
+declare function hashContent(content: string): string;
+/**
+ * Generates a SHA-256 hash of frontmatter fields.
+ *
+ * @remarks
+ * Excludes timestamp-related fields (`publishedTime`, `modifiedTime`, `head`,
+ * `article:published_time`, `article:modified_time`) to prevent circular
+ * dependencies in change detection. Keys are sorted alphabetically before
+ * hashing to ensure consistent results regardless of object key order.
+ *
+ * @param frontmatter - The frontmatter object to hash
+ * @returns Hexadecimal SHA-256 hash string
+ *
+ * @example
+ * ```typescript
+ * import { hashFrontmatter } from "@tsdoctor/snapshot";
+ *
+ * const hash = hashFrontmatter({
+ *   title: "My Page",
+ *   description: "Page description"
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function hashFrontmatter(frontmatter: Record<string, unknown>): string;
+//#endregion
+//#region src/SnapshotService.d.ts
+/**
+ * A tracked snapshot of one generated file: its content/frontmatter hashes
+ * and the timestamps preserved across incremental builds.
+ *
+ * @public
+ */
+interface FileSnapshot {
+  /** Output directory the file was generated into. */
+  readonly outputDir: string;
+  /** File path relative to `outputDir`. */
+  readonly filePath: string;
+  /** ISO timestamp of first publication, preserved for unchanged files. */
+  readonly publishedTime: string;
+  /** ISO timestamp of last content change. */
+  readonly modifiedTime: string;
+  /** SHA-256 hash of the normalized file body. */
+  readonly contentHash: string;
+  /** SHA-256 hash of the frontmatter (timestamp fields excluded). */
+  readonly frontmatterHash: string;
+  /** ISO timestamp of the build that last wrote this snapshot. */
+  readonly buildTime: string;
+}
+declare const SnapshotDbError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SnapshotDbError";
+} & Readonly<A>;
+/**
+ * Raised when a snapshot database operation fails.
+ *
+ * @public
+ */
+declare class SnapshotDbError extends SnapshotDbError_base<{
+  /** The database operation that failed (e.g. `"query"`). */
+  readonly operation: string;
+  /** Path or label of the database the operation ran against. */
+  readonly dbPath: string;
+  /** Human-readable failure reason. */
+  readonly reason: string;
+}> {
+  /** Formatted failure message combining operation, path and reason. */
+  get message(): string;
+}
+/**
+ * The operations {@link SnapshotService} provides for tracking generated
+ * files across incremental builds.
+ *
+ * @public
+ */
+interface SnapshotServiceShape {
+  /** Hash normalized content with SHA-256 (pure, synchronous). */
+  readonly hashContent: (content: string) => string;
+  /** Look up a single snapshot by output directory and file path. */
+  readonly getSnapshot: (outputDir: string, filePath: string) => Effect.Effect<Option.Option<FileSnapshot>, SnapshotDbError>;
+  /** Load every snapshot recorded for an output directory. */
+  readonly getAllForDirectory: (outputDir: string) => Effect.Effect<ReadonlyArray<FileSnapshot>, SnapshotDbError>;
+  /** List the tracked file paths for an output directory. */
+  readonly getFilePaths: (outputDir: string) => Effect.Effect<ReadonlyArray<string>, SnapshotDbError>;
+  /** Insert or update a single snapshot. */
+  readonly upsert: (snapshot: FileSnapshot) => Effect.Effect<boolean, SnapshotDbError>;
+  /** Insert or update many snapshots in one transaction; returns the count. */
+  readonly batchUpsert: (snapshots: ReadonlyArray<FileSnapshot>) => Effect.Effect<number, SnapshotDbError>;
+  /** Remove a single snapshot row. */
+  readonly deleteSnapshot: (outputDir: string, filePath: string) => Effect.Effect<void, SnapshotDbError>;
+  /**
+   * Delete rows for files no longer generated; returns the stale file paths.
+   */
+  readonly cleanupStale: (outputDir: string, currentFiles: ReadonlySet<string>) => Effect.Effect<ReadonlyArray<string>, SnapshotDbError>;
+}
+declare const SnapshotService_base: Context.ServiceClass<SnapshotService, "@tsdoctor/snapshot/SnapshotService", SnapshotServiceShape>;
+/**
+ * Effect service tag for the snapshot tracking store.
+ *
+ * @remarks
+ * Provided by {@link SnapshotServiceLive}, which backs it with a
+ * schema-versioned SQLite database via `@effected/store`.
+ *
+ * @public
+ */
+declare class SnapshotService extends SnapshotService_base {}
+//#endregion
+//#region src/SnapshotServiceLive.d.ts
+/**
+ * Builds the live {@link SnapshotService} layer over a SQLite database file.
+ *
+ * @remarks
+ * Backed by `@effected/store`'s `Store.layerSqlite`: layer construction opens
+ * the database (WAL mode), ensures the migration ledger and applies pending
+ * migrations. A WAL checkpoint (`PRAGMA wal_checkpoint(TRUNCATE)`) is
+ * registered as a scope finalizer so the sidecar files are folded back into
+ * the main database on clean shutdown.
+ *
+ * This is a parameterized layer factory: call it once per database path and
+ * bind the result to a `const` — layers memoize by reference, and a fresh
+ * call at each provide site would open the database more than once. The
+ * parent directory of `dbPath` must already exist.
+ *
+ * @param dbPath - Path to the SQLite database file
+ * @returns A layer providing {@link SnapshotService}
+ * @public
+ */
+declare const SnapshotServiceLive: (dbPath: string) => Layer.Layer<SnapshotService, StoreError | StoreMigrationError>;
+//#endregion
+export { type FileSnapshot, SnapshotDbError, SnapshotService, SnapshotServiceLive, type SnapshotServiceShape, hashContent, hashFrontmatter, normalizeContent };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,5 @@
+import { hashContent, hashFrontmatter, normalizeContent } from "./content-hash.js";
+import { SnapshotDbError, SnapshotService } from "./SnapshotService.js";
+import { SnapshotServiceLive } from "./SnapshotServiceLive.js";
+
+export { SnapshotDbError, SnapshotService, SnapshotServiceLive, hashContent, hashFrontmatter, normalizeContent };

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@tsdoctor/snapshot",
+	"version": "0.1.0",
+	"private": false,
+	"description": "Incremental-build snapshot tracking for static documentation pipelines: a schema-versioned SQLite store of per-file content hashes and timestamps, built on @effected/store, plus the pure SHA-256 content-hashing helpers that feed it.",
+	"keywords": [
+		"snapshot",
+		"incremental-build",
+		"sqlite",
+		"content-hash",
+		"effect",
+		"documentation"
+	],
+	"homepage": "https://github.com/spencerbeggs/tsdoctor#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/tsdoctor/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/tsdoctor.git",
+		"directory": "packages/snapshot"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js",
+			"default": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"peerDependencies": {
+		"@effected/store": "^0.4.0",
+		"effect": "4.0.0-rc.109"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.0"
+    }
+  ]
+}