@sasjs/api 0.0.0-stage → 0.1.0

package/build/esm/routes/index.d.ts

@@ -0,0 +1,18 @@
+import type { Route } from '../types.js';
+export declare const ROUTES: Route[];
+/** The route with this `METHOD /path` identity, if the document has one. */
+export declare const routeById: (id: string) => Route | undefined;
+export interface RouteMatch {
+    route: Route;
+    /** Values captured from the path's `{placeholders}`. */
+    params: Record<string, string>;
+}
+/**
+ * The route a request names, or undefined when the API has no such operation.
+ *
+ * A host that gets undefined answers 404 "not part of the API"; a host that gets
+ * a route it cannot serve answers 501 naming the capability. Keeping those two
+ * apart is the difference between a client's bug and a host's limit.
+ */
+export declare const findRoute: (method: string, path: string) => RouteMatch | undefined;
+//# sourceMappingURL=index.d.ts.map

package/build/esm/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,KAAK,EAAiB,MAAM,aAAa,CAAA;AAyCvD,eAAO,MAAM,MAAM,EAAE,KAAK,EAAgC,CAAA;AAW1D,4EAA4E;AAC5E,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,KAAG,KAAK,GAAG,SAAyB,CAAA;AAExE,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAgCD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GACpB,QAAQ,MAAM,EACd,MAAM,MAAM,KACX,UAAU,GAAG,SAuBf,CAAA"}

package/build/esm/routes/index.js

@@ -0,0 +1,106 @@
+/**
+ * The route table, and the one matcher both hosts dispatch with.
+ *
+ * `GENERATED_ROUTES` is the OpenAPI document, `OVERLAY` is the part a document
+ * cannot carry, and this file is where they meet. Importing it validates the
+ * join as a side effect: an overlay entry naming an operation the document does
+ * not have is a stale entry, and it throws here rather than being silently
+ * ignored - the failure mode that lets a "documented" behaviour rot.
+ */
+import { GENERATED_ROUTES } from './generated.js';
+import { OVERLAY, TAG_CAPABILITIES } from './overlay.js';
+const merge = (generated) => {
+    const overlay = OVERLAY[generated.id] || {};
+    const documented = new Map(generated.responses.map((r) => [r.status, r.description]));
+    // The document states the statuses and the overlay only annotates the ones a
+    // client keys a body on. Naming a status the document does not state is a
+    // build failure: the alternative - listing it anyway - advertises a status
+    // nothing can observe without the parity test failing, which is a documented
+    // wish rather than a contract. A host that genuinely answers a status the
+    // document omits needs the document corrected in sasjs/server.
+    for (const status of Object.keys(overlay.responses || {}).map(Number)) {
+        if (!documented.has(status)) {
+            throw new Error(`src/routes/overlay.ts annotates status ${status} for ${generated.id}, which the OpenAPI document does not state. Correct the document in sasjs/server and re-vendor spec/swagger.yaml, or drop the annotation.`);
+        }
+    }
+    const responses = [...documented.keys()]
+        .sort((a, b) => a - b)
+        .map((status) => {
+        const body = overlay.responses ? overlay.responses[status] : undefined;
+        return {
+            status,
+            description: documented.get(status) || '',
+            ...(body === undefined ? {} : { body })
+        };
+    });
+    return {
+        ...generated,
+        responses,
+        capabilities: overlay.capabilities || TAG_CAPABILITIES[generated.tag] || [],
+        implemented: overlay.implemented === true
+    };
+};
+export const ROUTES = GENERATED_ROUTES.map(merge);
+const known = new Set(ROUTES.map((route) => route.id));
+for (const id of Object.keys(OVERLAY))
+    if (!known.has(id))
+        throw new Error(`src/routes/overlay.ts names an operation the OpenAPI document does not have: ${id}. Remove the entry or refresh spec/swagger.yaml.`);
+const byId = new Map(ROUTES.map((route) => [route.id, route]));
+/** The route with this `METHOD /path` identity, if the document has one. */
+export const routeById = (id) => byId.get(id);
+const escape = (segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Compiles a documented path into a matcher. The table is static, so this runs
+ * once at import; `findRoute` then tests exact paths first (most of the API is
+ * static) and only falls through to the templates for `{uid}`-style paths.
+ */
+const compiled = ROUTES.filter((route) => route.path.includes('{')).map((route) => {
+    const keys = [];
+    const pattern = route.path
+        .split('/')
+        .map((segment) => {
+        if (segment.startsWith('{') && segment.endsWith('}')) {
+            keys.push(segment.slice(1, -1));
+            return '([^/]+)';
+        }
+        return escape(segment);
+    })
+        .join('/');
+    return { route, keys, regex: new RegExp('^' + pattern + '/?$') };
+});
+const exact = new Map();
+for (const route of ROUTES)
+    if (!route.path.includes('{'))
+        exact.set(route.method + ' ' + route.path, route);
+/**
+ * The route a request names, or undefined when the API has no such operation.
+ *
+ * A host that gets undefined answers 404 "not part of the API"; a host that gets
+ * a route it cannot serve answers 501 naming the capability. Keeping those two
+ * apart is the difference between a client's bug and a host's limit.
+ */
+export const findRoute = (method, path) => {
+    const verb = method.toUpperCase();
+    const clean = path.split('?')[0].replace(/\/+$/, '') || '/';
+    const hit = exact.get(verb + ' ' + clean);
+    if (hit)
+        return { route: hit, params: {} };
+    for (const candidate of compiled) {
+        if (candidate.route.method !== verb)
+            continue;
+        const match = candidate.regex.exec(clean);
+        if (!match)
+            continue;
+        const params = {};
+        candidate.keys.forEach((key, index) => {
+            try {
+                params[key] = decodeURIComponent(match[index + 1]);
+            }
+            catch {
+                params[key] = match[index + 1];
+            }
+        });
+        return { route: candidate.route, params };
+    }
+    return undefined;
+};

package/build/esm/routes/overlay.d.ts

@@ -0,0 +1,40 @@
+/**
+ * What the OpenAPI document cannot say.
+ *
+ * The generated table states the route's shape - method, path, parameters,
+ * documented responses. This file adds the three things a document has no room
+ * for, each of which a host or a test needs:
+ *
+ *   - the body a response carries, because a client keys on `{"status":
+ *     "success"}` and on the wording of a refusal, not on a status alone. A
+ *     refusal's body is the message as a plain string: the drive routes answer
+ *     `res.status(code).send(err.message)`, and sasjs/server's own suite asserts
+ *     `res.text`. A host renders that in its own transport - a text body on the
+ *     server, `text(...)` in the worker - and never wraps it in an envelope the
+ *     server does not send;
+ *   - which capability the route needs, so a host can answer 501 with a reason
+ *     instead of 404 with none;
+ *   - whether this package implements it yet, so "not done" is visible.
+ *
+ * The statuses come from the document, and an overlay body is attached to the
+ * status it belongs to: naming a status the document does not state is a build
+ * failure, not a way to describe a divergence. A divergence between the document
+ * and the code is a bug in one of them, corrected at source in `sasjs/server` and
+ * re-vendored here.
+ */
+import type { Capability, HttpMethod } from '../types.js';
+export interface RouteOverlay {
+    capabilities?: Capability[];
+    implemented?: boolean;
+    /**
+     * The body the operation sends with a status, where a client keys on it. The
+     * statuses come from the document; this only annotates them.
+     */
+    responses?: Record<number, unknown>;
+}
+/** The default capability for each tag, overridden per route where it differs. */
+export declare const TAG_CAPABILITIES: Record<string, Capability[]>;
+export declare const OVERLAY: Record<string, RouteOverlay>;
+/** Every method the table may state, in the order a diff reads best. */
+export declare const METHODS: HttpMethod[];
+//# sourceMappingURL=overlay.d.ts.map

package/build/esm/routes/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/routes/overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEzD,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,UAAU,EAAE,CAAA;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAED,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,CAczD,CAAA;AAID,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAoDhD,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,OAAO,EAAE,UAAU,EAA8C,CAAA"}

package/build/esm/routes/overlay.js

@@ -0,0 +1,72 @@
+/** The default capability for each tag, overridden per route where it differs. */
+export const TAG_CAPABILITIES = {
+    Drive: ['storage'],
+    STP: ['runtime', 'storage'],
+    Code: ['runtime'],
+    Session: ['runtime'],
+    Info: [],
+    Admin: ['storage'],
+    Auth: ['identity'],
+    'Auth Config': ['identity'],
+    User: ['identity'],
+    Group: ['identity'],
+    Permission: ['identity'],
+    Client: ['identity'],
+    Web: ['identity']
+};
+const success = { status: 'success' };
+export const OVERLAY = {
+    // the route inventory reports what the CALLER may use, so it needs an identity
+    // even though the rest of the Info tag needs nothing
+    'GET /SASjsApi/info/authorizedRoutes': { capabilities: ['identity'] },
+    'GET /SASjsApi/info/myAuthorizedRoutes': { capabilities: ['identity'] },
+    // the body is the file itself, so there is nothing to annotate
+    'GET /SASjsApi/drive/file': { implemented: true },
+    'POST /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 409: 'File already exists.' }
+    },
+    'PATCH /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    'DELETE /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    'GET /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: { files: [], folders: [] } }
+    },
+    'POST /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: success, 409: 'Folder already exists.' }
+    },
+    'DELETE /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: success, 404: `Folder doesn't exist.` }
+    },
+    'POST /SASjsApi/drive/rename': {
+        implemented: true,
+        responses: {
+            200: success,
+            409: 'File with new name already exists.',
+            404: 'No file/folder found for provided path.'
+        }
+    },
+    'GET /SASjsApi/drive/filetree': {
+        implemented: true,
+        responses: { 200: { status: 'success', tree: {} } }
+    },
+    // The two deploy routes write a whole tree in one request. They are the only
+    // ones where a caller can exhaust the host's storage, so they carry a cap -
+    // see the plan in sasjs/cli#1550 - and they are not implemented yet.
+    'POST /SASjsApi/drive/deploy': {
+        implemented: false
+    },
+    'POST /SASjsApi/drive/deploy/upload': {
+        implemented: false
+    }
+};
+/** Every method the table may state, in the order a diff reads best. */
+export const METHODS = ['GET', 'POST', 'PATCH', 'DELETE', 'PUT'];

package/build/esm/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The vocabulary the two hosts share.
+ *
+ * Nothing here imports a runtime: the package is consumed by an Express server
+ * in node and by a service worker in a browser, so the types are all this file
+ * may contain. That is also why the build compiles `src` with `types: []` - an
+ * accidental `Buffer` or `process` reference fails the build rather than the
+ * worker at run time.
+ */
+/**
+ * A refusal the API answers with: the status a client keys on, and the message
+ * it prints. Both hosts throw this and both render it the same way, so the
+ * corpus can assert on the pair.
+ */
+export declare class ApiError extends Error {
+    readonly status: number;
+    /** Told apart by marker rather than `instanceof` - see `isApiError`. */
+    readonly apiError = true;
+    constructor(status: number, message: string);
+}
+/**
+ * `instanceof` survives here (the package targets ES2020, not ES5), but a
+ * consumer that downlevels it - the CLI does - loses the prototype chain, so the
+ * marker is what the checks use. Asserting both in a spec is what keeps that
+ * honest.
+ */
+export declare const isApiError: (value: unknown) => value is ApiError;
+/**
+ * What a route needs from a host in order to answer it.
+ *
+ * `runtime` is a program runtime - the host decides which languages it holds
+ * (the browser build runs JavaScript, a server runs JavaScript and SAS) and
+ * answers 501 when the program it was given is in a language it has no runtime
+ * for. `sas` is a SAS engine specifically, for a route that cannot be answered
+ * without one.
+ */
+export type Capability = 'runtime' | 'storage' | 'identity' | 'sas' | 'node';
+export type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE' | 'PUT';
+export type ParamLocation = 'query' | 'path' | 'body' | 'formData' | 'header';
+export interface RouteParam {
+    name: string;
+    in: ParamLocation;
+    required: boolean;
+    /** JSON-schema type as the OpenAPI document words it. */
+    type: string;
+    enum?: string[];
+}
+export interface RouteResponse {
+    status: number;
+    description: string;
+    /** The body the server actually sends, where the corpus pins one. */
+    body?: unknown;
+}
+/** An operation exactly as the OpenAPI document states it. */
+export interface GeneratedRoute {
+    id: string;
+    method: HttpMethod;
+    path: string;
+    tag: string;
+    summary: string;
+    params: RouteParam[];
+    requestBodies: string[];
+    responses: Array<{
+        status: number;
+        description: string;
+    }>;
+}
+export interface Route extends GeneratedRoute {
+    responses: RouteResponse[];
+    capabilities: Capability[];
+    /**
+     * Whether this package carries a handler for the operation. A host may still
+     * refuse it for a missing capability - that is a 501 naming the capability,
+     * not an absence nobody can see.
+     */
+    implemented: boolean;
+}
+/**
+ * The drive, as the services see it.
+ *
+ * Every path is drive-relative and already normalised by `normaliseDrivePath`:
+ * it starts with `/`, never contains `.` or `..`, and cannot leave the drive.
+ * The store owns the translation to wherever the bytes actually live - a folder
+ * under node, a Map in the browser - and owns the representation it uses to do
+ * it (text vs bytes).
+ */
+export interface DriveStore {
+    read(path: string): Promise<string | Uint8Array>;
+    write(path: string, contents: string | Uint8Array): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<{
+        directory: boolean;
+        size: number;
+    }>;
+    list(path: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    mkdirp(path: string): Promise<void>;
+    /** Removes a file, or a folder with everything under it. */
+    remove(path: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+}
+export interface TreeNode {
+    name: string;
+    relativePath: string;
+    isFolder: boolean;
+    children: TreeNode[];
+}
+//# sourceMappingURL=types.d.ts.map

package/build/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,qBAAa,QAAS,SAAQ,KAAK;IAK/B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAJzB,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,QAAO;gBAGb,MAAM,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM;CAKlB;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QACH,CAAA;AAElD;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,SAAS,GACT,UAAU,GACV,KAAK,GACL,MAAM,CAAA;AAEV,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAA;AAEpE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAA;AAE7E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,aAAa,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,qEAAqE;IACrE,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,SAAS,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC1D;AAED,MAAM,WAAW,KAAM,SAAQ,cAAc;IAC3C,SAAS,EAAE,aAAa,EAAE,CAAA;IAC1B,YAAY,EAAE,UAAU,EAAE,CAAA;IAC1B;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,UAAU,CAAC,CAAA;IAChD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACjE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACjE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAA;IACnE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,4DAA4D;IAC5D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC9C;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,QAAQ,EAAE,CAAA;CACrB"}

package/build/esm/types.js

@@ -0,0 +1,30 @@
+/**
+ * The vocabulary the two hosts share.
+ *
+ * Nothing here imports a runtime: the package is consumed by an Express server
+ * in node and by a service worker in a browser, so the types are all this file
+ * may contain. That is also why the build compiles `src` with `types: []` - an
+ * accidental `Buffer` or `process` reference fails the build rather than the
+ * worker at run time.
+ */
+/**
+ * A refusal the API answers with: the status a client keys on, and the message
+ * it prints. Both hosts throw this and both render it the same way, so the
+ * corpus can assert on the pair.
+ */
+export class ApiError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        /** Told apart by marker rather than `instanceof` - see `isApiError`. */
+        this.apiError = true;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * `instanceof` survives here (the package targets ES2020, not ES5), but a
+ * consumer that downlevels it - the CLI does - loses the prototype chain, so the
+ * marker is what the checks use. Asserting both in a spec is what keeps that
+ * honest.
+ */
+export const isApiError = (value) => !!value && value.apiError === true;

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@sasjs/api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The SASjs Server API, described once - a generated route table, the services behind it, and the conformance corpus both hosts run",
+  "license": "MIT",
+  "author": "SASjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sasjs/api.git"
+  },
+  "homepage": "https://github.com/sasjs/api#readme",
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/esm/index.d.ts",
+      "import": "./build/esm/index.js",
+      "require": "./build/cjs/index.js"
+    }
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENCE.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "rimraf build && tsc -p tsconfig.build.cjs.json && tsc -p tsconfig.build.esm.json && node scripts/postbuild.mjs && node scripts/build-browser.mjs",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "lint": "prettier --check \"{src,spec,scripts}/**/*.{ts,mjs,md}\" \"*.{json,md}\"",
+    "lint:fix": "prettier --write \"{src,spec,scripts}/**/*.{ts,mjs,md}\" \"*.{json,md}\"",
+    "sync:routes": "node scripts/sync-routes.mjs",
+    "check:routes": "node scripts/sync-routes.mjs --check"
+  },
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/github": "12.0.10",
+    "@semantic-release/npm": "13.2.0",
+    "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/jest": "29.5.14",
+    "@types/node": "22.20.5",
+    "esbuild": "0.28.2",
+    "jest": "29.7.0",
+    "prettier": "3.9.10",
+    "rimraf": "6.1.4",
+    "semantic-release": "25.0.9",
+    "ts-jest": "29.4.15",
+    "typescript": "5.9.3",
+    "yaml": "2.9.1"
+  }
+}