ts-data-forge 3.2.0 → 3.3.1

package/dist/others/unknown-to-string.mjs

@@ -3,11 +3,13 @@ import { isNonNullish } from '../guard/is-type.mjs';
 /**
  * Converts an unknown value to its string representation in a type-safe manner.
  *
- * This function handles all JavaScript types and provides consistent string conversion
- * with proper error handling for edge cases like circular references. Unlike naive
- * toString() calls, this function never throws and handles all value types gracefully.
+ * This function handles all JavaScript types and provides consistent string
+ * conversion with proper error handling for edge cases like circular
+ * references. Unlike naive toString() calls, this function never throws and
+ * handles all value types gracefully.
  *
  * **Type conversion rules:**
+ *
  * - Strings: returned as-is
  * - Numbers, booleans, bigints: converted via toString()
  * - Symbols: converted to their description string
@@ -18,137 +20,22 @@ import { isNonNullish } from '../guard/is-type.mjs';
  *
  * @param value - The unknown value to convert to string
  * @param options - Optional configuration for the conversion
- * @param options.prettyPrintObject - If true, objects are formatted with 2-space indentation
- * @returns The string representation of the value. For circular references or non-serializable objects, returns an error message string
- *
- * @example Basic type conversions
- * ```typescript
- * // Primitive types
- * unknownToString('hello');        // 'hello'
- * unknownToString(123);            // '123'
- * unknownToString(true);           // 'true'
- * unknownToString(null);           // 'null'
- * unknownToString(undefined);      // 'undefined'
- * unknownToString(Symbol('test')); // 'Symbol(test)'
- * unknownToString(123n);           // '123'
- *
- * // Function conversion
- * const fn = () => 'test';
- * unknownToString(fn); // "() => 'test'"
- * ```
- *
- * @example Object stringification
- * ```typescript
- * // Simple object
- * const obj = { a: 1, b: 'hello', c: [1, 2, 3] };
- * const result = unknownToString(obj);
- * console.log(result); // '{"a":1,"b":"hello","c":[1,2,3]}'
- *
- * // Pretty printing
- * const prettyResult = unknownToString(obj, { prettyPrintObject: true });
- * console.log(prettyResult);
- * // {
- * //   "a": 1,
- * //   "b": "hello",
- * //   "c": [
- * //     1,
- * //     2,
- * //     3
- * //   ]
- * // }
- * ```
- *
- * @example Error handling for circular references
- * ```typescript
- * // Circular reference
- * const circular: any = { name: 'parent' };
- * circular.self = circular;
- *
- * const result = unknownToString(circular);
- * console.log(result); // "Converting circular structure to JSON"
- *
- * @example Logging and debugging utilities
- * ```typescript
- * // Type-safe logger
- * class Logger {
- *   log(message: string, data?: unknown): void {
- *     const timestamp = new Date().toISOString();
- *     const dataStr = data !== undefined
- *       ? unknownToString(data, { prettyPrintObject: true })
- *       : '';
- *
- *     console.log(`[${timestamp}] ${message}`, dataStr);
- *   }
- * }
- *
- * const logger = new Logger();
- * logger.log('User data:', { id: 123, name: 'John' });
- * ```
- *
- * @example API response formatting
- * ```typescript
- * // Safe error response formatting
- * function formatErrorResponse(error: unknown): string {
- *   const errorStr = unknownToString(error, { prettyPrintObject: true });
+ * @param options.prettyPrintObject - If true, objects are formatted with
+ *   2-space indentation
+ * @returns The string representation of the value. For circular references or
+ *   non-serializable objects, returns an error message string
  *
- *   return JSON.stringify({
- *     success: false,
- *     error: errorStr
- *   });
- * }
- *
- * try {
- *   // some operation
- * } catch (error) {
- *   const response = formatErrorResponse(error);
- *   res.status(500).send(response);
- * }
- * ```
- *
- * @example Working with special objects
- * ```typescript
- * // Date objects
- * unknownToString(new Date('2023-01-01'));
- * // '"2023-01-01T00:00:00.000Z"' - JSON stringified
- *
- * // Regular expressions
- * unknownToString(/test/gi);
- * // '{}' - RegExp has no enumerable properties
- *
- * // Arrays
- * unknownToString([1, 'two', { three: 3 }]);
- * // '[1,"two",{"three":3}]'
- *
- * // Map and Set (converted to empty objects by JSON.stringify)
- * unknownToString(new Map([['a', 1]])); // '{}'
- * unknownToString(new Set([1, 2, 3]));   // '{}'
- * ```
- *
- * @example Using with validation
- * ```typescript
- * // Simple validation helper
- * function validateAndStringify(input: unknown): string {
- *   const str = unknownToString(input);
- *   const trimmed = str.trim();
- *
- *   if (trimmed.length === 0) {
- *     throw new Error('Empty string');
- *   }
- *
- *   return trimmed;
- * }
- * ```
- *
- * **Error Handling:**
- * Circular references and non-serializable objects return descriptive error messages instead of throwing
+ *   **Error Handling:** Circular references and non-serializable objects return
+ *   descriptive error messages instead of throwing
  * @see JSON.stringify - Underlying serialization for objects
  */
 const unknownToString = (value, options) => {
     switch (typeof value) {
         case 'string':
             return value;
-        case 'number':
         case 'bigint':
+            return `${value.toString()}n`;
+        case 'number':
         case 'boolean':
         case 'symbol':
         case 'function':
@@ -164,7 +51,7 @@ const unknownToString = (value, options) => {
                 return stringified;
             }
             catch (error) {
-                return error instanceof Error
+                return Error.isError(error)
                     ? error.message
                     : '[Circular or Non-serializable]';
             }

package/dist/others/unknown-to-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,KAAK,YAAY;sBACpB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG;AAE/B,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;AACd,gBAAA,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK;sBACtB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}

package/dist/promise/promise.d.mts

@@ -1,32 +1,45 @@
 import { Result } from '../functional/index.mjs';
 /**
- * Creates a Promise that wraps the result in a Result type for type-safe error handling.
- * This function is an alternative to `new Promise(executor)` that provides enhanced type safety
- * by returning a Result type instead of throwing exceptions.
- *
- * @template S - The type of successful value
- * @template E - The type of error value
- * @param executor - Function that takes resolve and reject callbacks
- * @returns A Promise that resolves to a Result containing either success or error
+ * Creates a Promise that wraps the result in a Result type for type-safe error
+ * handling. This function is an alternative to `new Promise(executor)` that
+ * provides enhanced type safety by returning a Result type instead of throwing
+ * exceptions.
  *
  * @example
- * ```typescript
- * const result = await createPromise<string, Error>((resolve, reject) => {
+ *
+ * ```ts
+ * // Create a promise that resolves successfully
+ * const successPromise = createPromise<number, string>((resolve) => {
+ *   setTimeout(() => {
+ *     resolve(42);
+ *   }, 0);
+ * });
+ *
+ * const successResult = await successPromise;
+ * assert.ok(Result.isOk(successResult));
+ * if (Result.isOk(successResult)) {
+ *   assert(successResult.value === 42);
+ * }
+ *
+ * // Create a promise that rejects with an error
+ * const errorPromise = createPromise<number, string>((_, reject) => {
  *   setTimeout(() => {
- *     if (Math.random() > 0.5) {
- *       resolve("Success!");
- *     } else {
- *       reject(new Error("Failed"));
- *     }
- *   }, 1000);
+ *     reject('Something went wrong');
+ *   }, 0);
  * });
  *
- * if (result.isOk()) {
- *   console.log(result.value); // "Success!"
- * } else {
- *   console.log(result.error); // Error: Failed
+ * const errorResult = await errorPromise;
+ * assert.ok(Result.isErr(errorResult));
+ * if (Result.isErr(errorResult)) {
+ *   assert(errorResult.value === 'Something went wrong');
  * }
  * ```
+ *
+ * @template S - The type of successful value
+ * @template E - The type of error value
+ * @param executor - Function that takes resolve and reject callbacks
+ * @returns A Promise that resolves to a Result containing either success or
+ *   error
  */
 export declare const createPromise: <S, E>(executor: (resolve: (value: S) => void, reject: (reason?: E) => void) => void) => Promise<Result<S, E>>;
 //# sourceMappingURL=promise.d.mts.map

package/dist/promise/promise.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"promise.d.mts","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,KAC5E,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIK,CAAC"}
+{"version":3,"file":"promise.d.mts","sourceRoot":"","sources":["../../src/promise/promise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,KAC5E,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAIK,CAAC"}

package/dist/promise/promise.mjs

@@ -2,36 +2,49 @@ import '../functional/optional.mjs';
 import { Result } from '../functional/result.mjs';
 
 /**
- * Creates a Promise that wraps the result in a Result type for type-safe error handling.
- * This function is an alternative to `new Promise(executor)` that provides enhanced type safety
- * by returning a Result type instead of throwing exceptions.
- *
- * @template S - The type of successful value
- * @template E - The type of error value
- * @param executor - Function that takes resolve and reject callbacks
- * @returns A Promise that resolves to a Result containing either success or error
+ * Creates a Promise that wraps the result in a Result type for type-safe error
+ * handling. This function is an alternative to `new Promise(executor)` that
+ * provides enhanced type safety by returning a Result type instead of throwing
+ * exceptions.
  *
  * @example
- * ```typescript
- * const result = await createPromise<string, Error>((resolve, reject) => {
+ *
+ * ```ts
+ * // Create a promise that resolves successfully
+ * const successPromise = createPromise<number, string>((resolve) => {
+ *   setTimeout(() => {
+ *     resolve(42);
+ *   }, 0);
+ * });
+ *
+ * const successResult = await successPromise;
+ * assert.ok(Result.isOk(successResult));
+ * if (Result.isOk(successResult)) {
+ *   assert(successResult.value === 42);
+ * }
+ *
+ * // Create a promise that rejects with an error
+ * const errorPromise = createPromise<number, string>((_, reject) => {
  *   setTimeout(() => {
- *     if (Math.random() > 0.5) {
- *       resolve("Success!");
- *     } else {
- *       reject(new Error("Failed"));
- *     }
- *   }, 1000);
+ *     reject('Something went wrong');
+ *   }, 0);
  * });
  *
- * if (result.isOk()) {
- *   console.log(result.value); // "Success!"
- * } else {
- *   console.log(result.error); // Error: Failed
+ * const errorResult = await errorPromise;
+ * assert.ok(Result.isErr(errorResult));
+ * if (Result.isErr(errorResult)) {
+ *   assert(errorResult.value === 'Something went wrong');
  * }
  * ```
+ *
+ * @template S - The type of successful value
+ * @template E - The type of error value
+ * @param executor - Function that takes resolve and reject callbacks
+ * @returns A Promise that resolves to a Result containing either success or
+ *   error
  */
 const createPromise = (executor) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Result.fromPromise(new Promise(executor));
 
 export { createPromise };

package/dist/promise/promise.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"promise.mjs","sources":["../../src/promise/promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,aAAa,GAAG,CAC3B,QAA6E;AAE7E;AACA,MAAM,CAAC,WAAW,CAAC,IAAI,OAAO,CAAI,QAAQ,CAAC;;;;"}
+{"version":3,"file":"promise.mjs","sources":["../../src/promise/promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,MAAM,aAAa,GAAG,CAC3B,QAA6E;AAE7E;AACA,MAAM,CAAC,WAAW,CAAC,IAAI,OAAO,CAAI,QAAQ,CAAC;;;;"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
 import './globals.d.mts';
-export * from './index.mjs';
+export * from './entry-point.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -22,11 +22,11 @@
     ".": {
       "import": {
         "types": "./dist/types.d.mts",
-        "default": "./dist/index.mjs"
+        "default": "./dist/entry-point.mjs"
       }
     }
   },
-  "module": "./dist/index.mjs",
+  "module": "./dist/entry-point.mjs",
   "types": "./dist/types.d.mts",
   "files": [
     "src",
@@ -35,41 +35,50 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsx ./scripts/cmd/build.mjs",
-    "check-all": "tsx ./scripts/cmd/check-all.mjs",
-    "check:ext": "tsx ./scripts/cmd/check-ext.mjs",
+    "build": "tsx ./scripts/cmd/build.mts",
+    "check-all": "tsx ./scripts/cmd/check-all.mts",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "cspell": "cspell \"**\" --gitignore --gitignore-root ./ --no-progress",
-    "doc": "tsx ./scripts/cmd/gen-docs.mjs",
-    "fmt": "format-diff-from origin/main",
+    "doc": "tsx ./scripts/cmd/gen-docs.mts",
+    "doc:embed-doc": "tsx ./scripts/cmd/embed-samples.mts",
+    "doc:embed-jsdoc": "tsx ./scripts/cmd/embed-jsdoc-examples.mts",
+    "doc:preview": "vite preview --config ./configs/vite.doc.config.ts",
+    "doc:watch": "typedoc --options ./configs/typedoc.config.mjs --watch",
+    "fmt": "format-uncommitted",
+    "fmt:diff": "format-diff-from origin/main",
     "fmt:full": "prettier --write .",
-    "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'",
+    "gh:apply-all": "run-s gh:apply-variables gh:apply-rulesets gh:apply-repository-settings",
+    "gh:apply-repository-settings": "tsx --env-file=.env scripts/github/repository/apply.mts",
+    "gh:apply-rulesets": "tsx --env-file=.env scripts/github/ruleset/apply.mts",
+    "gh:apply-variables": "tsx --env-file=.env scripts/github/variables/apply.mts",
+    "gh:backup-all": "run-s gh:backup-rulesets gh:backup-repository-settings",
+    "gh:backup-repository-settings": "tsx --env-file=.env scripts/github/repository/backup.mts",
+    "gh:backup-rulesets": "tsx --env-file=.env scripts/github/ruleset/backup.mts",
+    "gi": "run-s gi:scripts gi:src fmt",
+    "gi:scripts": "gen-index-ts ./scripts/github --index-ext .mts --export-ext .mjs --target-ext .mts --exclude cmd --exclude apply.mts --exclude octokit.mts",
+    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude array",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "lint:samples": "eslint ./samples",
     "md": "markdownlint-cli2",
-    "test": "npm run z:vitest -- run",
-    "test:cov": "npm run z:vitest -- run --coverage",
+    "test": "pnpm run z:vitest run",
+    "test:cov": "pnpm run z:vitest run --coverage",
     "test:cov:ui": "vite preview --outDir ./coverage",
-    "test:samples": "vitest --config ./samples/vitest.config.ts",
-    "test:ui": "npm run z:vitest -- --ui",
-    "testw": "npm run z:vitest -- watch",
-    "testw:samples": "npm run test:samples -- watch",
+    "test:ui": "pnpm run z:vitest --ui",
+    "testw": "pnpm run z:vitest watch",
     "tsc": "tsc --noEmit",
     "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
-    "tscw:samples": "tsc --noEmit --watch -p ./samples/tsconfig.json",
     "type-check": "tsc --noEmit",
-    "type-check:samples": "tsc --noEmit -p ./samples/tsconfig.json",
-    "update-packages": "npx npm-check-updates -u --install always",
+    "update-packages": "pnpm update --latest",
     "z:vitest": "vitest --config ./configs/vitest.config.ts"
   },
   "dependencies": {
-    "ts-type-forge": "^2.2.0"
+    "ts-type-forge": "^2.3.0"
   },
   "devDependencies": {
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
-    "@eslint/js": "^9.34.0",
-    "@mui/material": "^7.3.1",
+    "@mui/material": "^7.3.4",
+    "@octokit/core": "^7.0.5",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-strip": "^3.0.4",
     "@rollup/plugin-typescript": "^12.1.4",
@@ -77,45 +86,40 @@
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.4",
-    "@semantic-release/npm": "^12.0.2",
-    "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^24.3.0",
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.0.0",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@sindresorhus/is": "^7.1.0",
+    "@types/node": "^24.8.1",
+    "@types/react": "^19.2.2",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
-    "cspell": "^9.2.0",
-    "eslint": "^9.34.0",
-    "eslint-import-resolver-typescript": "4.4.4",
-    "eslint-plugin-array-func": "5.0.2",
-    "eslint-plugin-functional": "9.0.2",
-    "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-prefer-arrow-functions": "3.6.2",
-    "eslint-plugin-promise": "7.2.1",
-    "eslint-plugin-security": "3.0.1",
-    "eslint-plugin-unicorn": "60.0.0",
-    "eslint-plugin-vitest": "0.5.4",
+    "cspell": "^9.2.1",
+    "eslint": "^9.38.0",
+    "eslint-config-typed": "^1.7.1",
     "fast-glob": "^3.3.3",
-    "immer": "^10.1.1",
+    "immer": "^10.1.3",
+    "markdownlint": "^0.39.0",
     "markdownlint-cli2": "^0.18.1",
+    "npm-run-all2": "^8.0.4",
+    "octokit-safe-types": "^1.1.1",
     "prettier": "^3.6.2",
-    "prettier-plugin-organize-imports": "^4.2.0",
+    "prettier-plugin-organize-imports": "^4.3.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.48.0",
-    "semantic-release": "^24.2.7",
-    "ts-repo-utils": "^6.0.3",
+    "rollup": "^4.52.4",
+    "semantic-release": "^25.0.0",
+    "ts-fortress": "^5.2.0",
+    "ts-repo-utils": "^7.7.2",
     "tslib": "^2.8.1",
-    "tsx": "^4.20.4",
-    "typedoc": "^0.28.10",
-    "typedoc-plugin-markdown": "^4.8.1",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.40.0",
+    "tsx": "^4.20.6",
+    "typedoc": "^0.28.14",
+    "typedoc-github-theme": "^0.3.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.10",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "typescript": ">=4.8"
-  },
-  "engines": {
-    "node": ">=20.11.0"
   }
 }