@conduit-client/service-renewable-resource-manager 3.22.0

package/LICENSE.txt

@@ -0,0 +1,27 @@
+*Attorney/Client Privileged + Confidential*
+
+Terms of Use for Public Code (Non-OSS)
+
+*NOTE:* Before publishing code under this license/these Terms of Use, please review https://salesforce.quip.com/WFfvAMKB18AL and confirm that you’ve completed all prerequisites described therein. *These Terms of Use may not be used or modified without input from IP and Product Legal.*
+
+*Terms of Use*
+
+Copyright 2022 Salesforce, Inc. All rights reserved. 
+
+These Terms of Use govern the download, installation, and/or use of this software provided by Salesforce, Inc. (“Salesforce”) (the “Software”), were last updated on April 15, 2022, ** and constitute a legally binding agreement between you and Salesforce. If you do not agree to these Terms of Use, do not install or use the Software. 
+ 
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the Software and derivative works subject to these Terms. These Terms shall be included in all copies or substantial portions of the Software. 
+
+Subject to the limited rights expressly granted hereunder, Salesforce reserves all rights, title, and interest in and to all intellectual property subsisting in the Software. No rights are granted to you hereunder other than as expressly set forth herein. Users residing in countries on the United States Office of Foreign Assets Control sanction list, or which are otherwise subject to a US export embargo, may not use the Software.
+ 
+Implementation of the Software may require development work, for which you are responsible. The Software may contain bugs, errors and incompatibilities and is made available on an AS IS basis without support, updates, or service level commitments. 
+ 
+Salesforce reserves the right at any time to modify, suspend, or discontinue, the Software (or any part thereof) with or without notice. You agree that Salesforce shall not be liable to you or to any third party for any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or proceeding made or brought against Salesforce by a third party arising out of or accruing from (a) your use of the Software, and (b) any application you develop with the Software that infringes any copyright, trademark, trade secret, trade dress, patent, or other intellectual property right of any person or defames any person or violates their rights of publicity or privacy (each a “Claim Against Salesforce”), and will indemnify Salesforce from any damages, attorney fees, and costs finally awarded against Salesforce as a result of, or for any amounts paid by Salesforce under a settlement approved by you in writing of, a Claim Against Salesforce, provided Salesforce (x) promptly gives you written notice of the Claim Against Salesforce, (y) gives you sole control of the defense and settlement of the Claim Against Salesforce (except that you may not settle any Claim Against Salesforce unless it unconditionally releases Salesforce of all liability), and (z) gives you all reasonable assistance, at your expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA, OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ 
+These Terms of Use shall be governed exclusively by the internal laws of the State of California, without regard to its conflicts of laws rules. Each party hereby consents to the exclusive jurisdiction of the state and federal courts located in San Francisco County, California to adjudicate any dispute arising out of or relating to these Terms of Use and the download, installation, and/or use of the Software. Except as expressly stated herein, these Terms of Use constitute the entire agreement between the parties, and supersede all prior and contemporaneous agreements, proposals, or representations, written or oral, concerning their subject matter. No modification, amendment, or waiver of any provision of these Terms of Use shall be effective unless it is by an update to these Terms of Use that Salesforce makes available, or is in writing and signed by the party against whom the modification, amendment, or waiver is to be asserted.
+
+_*Data Privacy*_: Salesforce may collect, process, and store device, system, and other information related to your use of the Software. This information includes, but is not limited to, IP address, user metrics, and other data (“Usage Data”). Salesforce may use Usage Data for analytics, product development, and marketing purposes. You acknowledge that files generated in conjunction with the Software may contain sensitive or confidential data, and you are solely responsible for anonymizing and protecting such data.  

package/README.md

@@ -0,0 +1,78 @@
+# `@conduit-client/service-renewable-resource-manager`
+
+A generic, pluggable service for managing a single **renewable resource** — a
+value you fetch, cache, hand out on demand, and re-fetch when it goes stale.
+CSRF tokens are the first consumer; SFAP JWTs and other renewable credentials
+fit the same shape.
+
+See the design rationale in
+[`adrs/2026-05-13-renewable-resource-manager-as-service.md`](../../../documentation/adrs/2026-05-13-renewable-resource-manager-as-service.md).
+
+## What it is
+
+- **Lazy & externally-triggered.** No TTL, no expiry tracking, no autonomous
+  renewal. It fetches on first `get()` and re-fetches only when a caller invokes
+  `refresh()`. "Renewable" describes the resource (it _can_ be re-fetched), not
+  a behavior of the manager.
+- **Single-flight.** Concurrent `get()`/`refresh()` calls share one in-flight
+  fetch.
+- **Refresh-storm bounded.** When many callers fail against the same stale value
+  at once, `refresh(staleValue)` collapses them to a single network round-trip
+  (see below).
+
+## Usage
+
+```ts
+import {
+  BasicRenewableResourceManager,
+  buildRenewableResourceManagerDescriptor,
+} from '@conduit-client/service-renewable-resource-manager/v1';
+
+const manager = new BasicRenewableResourceManager<string>({
+  fetch: () => fetchTokenFromServer(), // "go to the network"
+  storage: {
+    get: () => durableStorage.get(KEY),
+    set: (v) => durableStorage.set(KEY, v),
+    clear: () => durableStorage.remove(KEY),
+  },
+});
+
+// register as a named, versioned service
+const descriptor = buildRenewableResourceManagerDescriptor('csrfToken', manager);
+```
+
+## API
+
+### `RenewableResourceManager<T extends string | number | boolean>`
+
+- `get(): PromiseLike<T | undefined>` — cached value, or fetch+cache if empty.
+- `refresh(staleValue?: T): PromiseLike<T | undefined>` — fetch fresh, overwrite
+  cache. With `staleValue`, short-circuits if storage already moved past it.
+- `clear(): PromiseLike<void>` — discard the cache (logout, org switch,
+  teardown). Routine staleness uses `refresh`, which is non-destructive.
+
+`T` is constrained to primitives so the storm-dedup comparison can use `===`.
+
+### Error contract
+
+- A **rejected** `PromiseLike` ⇒ the fetch could not complete (network/server
+  error). Rejections propagate; they are never swallowed into `undefined`.
+- A **resolved `undefined`** ⇒ the fetch completed and there is genuinely no
+  value. The cache is **not** cleared in this case — use `clear()` for that.
+
+### Refresh-storm dedup, by timing regime
+
+1. **Concurrent** failures (arriving while a fetch is in flight) share that
+   fetch via single-flight.
+2. **Late** failures (arriving after the first refresh stored a fresh value) are
+   caught by `refresh(staleValue)`: storage no longer holds `staleValue`, so the
+   stored value is returned with no network hop.
+
+### Storage adapter preconditions
+
+The manager relies on (but cannot enforce):
+
+- writes are durable before the returned `PromiseLike` resolves;
+- reads observe the most recent settled write (read-your-writes);
+- the manager is the **sole writer** of the slot, and replacement is monotonic —
+  the storm-dedup treats "stored differs from stale" as "someone refreshed."

package/dist/main/index.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/types/v1/__tests__/basic-renewable-resource-manager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/v1/basic-renewable-resource-manager.d.ts

@@ -0,0 +1,51 @@
+import type { RenewableResourceManager } from './renewable-resource-manager';
+/**
+ * Storage adapter supplied by the runtime. Preconditions the manager relies on
+ * but cannot enforce:
+ *
+ * - **Durable before resolution**: the `PromiseLike` returned by `set`/`clear`
+ *   resolves only after the write is observable by a subsequent `get`.
+ * - **Read-your-writes**: a `get` after a settled `set` observes that value.
+ * - **Sole writer / monotonic replacement**: the manager is the only writer of
+ *   this slot. The storm-dedup in {@link BasicRenewableResourceManager.refresh}
+ *   treats "stored value differs from the stale value" as "someone already
+ *   refreshed"; a third party mutating storage out from under the manager
+ *   (e.g. a server-pushed value) breaks that assumption.
+ */
+export interface ResourceStorage<T> {
+    get: () => PromiseLike<T | undefined>;
+    set: (value: T) => PromiseLike<void>;
+    clear: () => PromiseLike<void>;
+}
+export interface BasicRenewableResourceManagerConfig<T extends string | number | boolean> {
+    /** Fetches a fresh value from the source of truth ("go to the network"). */
+    fetch: () => PromiseLike<T | undefined>;
+    storage: ResourceStorage<T>;
+}
+/**
+ * Configurable building block implementing {@link RenewableResourceManager}.
+ *
+ * The runtime supplies `fetch` and `storage`; the building block adds
+ * single-flight fetch coalescing and refresh-storm deduplication. It holds no
+ * opinion on storage backend, TTL, or initialization strategy — a consumer with
+ * a preloaded value seeds `storage` before constructing the manager, so the
+ * first `get` finds it and skips `fetch`.
+ *
+ * The implementation chains `PromiseLike` directly rather than using
+ * `async`/`await` so a synchronous source stays synchronous and avoids a
+ * microtask hop.
+ */
+export declare class BasicRenewableResourceManager<T extends string | number | boolean> implements RenewableResourceManager<T> {
+    private readonly config;
+    private inFlightFetch;
+    constructor(config: BasicRenewableResourceManagerConfig<T>);
+    get(): PromiseLike<T | undefined>;
+    refresh(staleValue?: T): PromiseLike<T | undefined>;
+    clear(): PromiseLike<void>;
+    /**
+     * Single in-flight fetch shared by all concurrent `get`/`refresh` callers.
+     * Overwrites storage on a successful fetch of a defined value only; a
+     * rejected fetch or a resolved-`undefined` leaves the cached value intact.
+     */
+    private fetchAndStore;
+}

package/dist/types/v1/index.d.ts

@@ -0,0 +1,14 @@
+import type { NamedService, ServiceDescriptor } from '@conduit-client/utils';
+import type { RenewableResourceManager } from './renewable-resource-manager';
+export type { RenewableResourceManager } from './renewable-resource-manager';
+export { BasicRenewableResourceManager, type BasicRenewableResourceManagerConfig, type ResourceStorage, } from './basic-renewable-resource-manager';
+export type NamedRenewableResourceManagerService<Name extends string> = NamedService<Name, RenewableResourceManager<any>>;
+export type RenewableResourceManagerServiceDescriptor<Name extends string> = ServiceDescriptor<RenewableResourceManager<any>, Name, '1.0'>;
+/**
+ * Builds a versioned service descriptor wrapping a {@link RenewableResourceManager}.
+ *
+ * The `type` is the resource name (e.g. `'csrfToken'`), so a runtime can
+ * register multiple independent managers — one per renewable resource — each
+ * resolvable by name through the provisioner.
+ */
+export declare function buildRenewableResourceManagerDescriptor<Name extends string, T extends string | number | boolean>(type: Name, service: RenewableResourceManager<T>): RenewableResourceManagerServiceDescriptor<Name>;

package/dist/types/v1/renewable-resource-manager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A `RenewableResourceManager` owns a single renewable resource: it caches a
+ * value, hands it out on demand, and re-fetches a fresh one when a caller
+ * signals the cached value is stale.
+ *
+ * It is **lazy** and **externally-triggered**: it has no TTL, no expiry
+ * tracking, and no autonomous renewal. It fetches on first demand and
+ * re-fetches only when a caller invokes {@link refresh}. "Renewable" describes
+ * the resource (it *can* be re-fetched), not an autonomous behavior of the
+ * manager.
+ *
+ * `T` is constrained to primitive types so the storm-dedup comparison in
+ * {@link refresh} can use `===` correctly. See {@link BasicRenewableResourceManager}.
+ *
+ * ## Error contract
+ *
+ * The methods distinguish *failure* from *absence*:
+ * - A **rejected** `PromiseLike` means the fetch could not complete (network or
+ *   server error). The caller (or a retry policy) decides whether to retry.
+ *   Rejections propagate; they are never swallowed into `undefined`.
+ * - A **resolved `undefined`** means the fetch completed and there is genuinely
+ *   no value (the configured `fetch` returned `undefined`).
+ */
+export interface RenewableResourceManager<T extends string | number | boolean> {
+    /**
+     * Returns the cached resource, or fetches and caches one if storage is empty.
+     * Concurrent calls (with `refresh`) share a single in-flight fetch.
+     *
+     * If called while a `refresh` is in flight, returns the *currently cached*
+     * value (what we have), not the value being fetched.
+     */
+    get(): PromiseLike<T | undefined>;
+    /**
+     * Fetches a fresh resource and overwrites the cached one (on success only).
+     *
+     * @param staleValue the value the caller held when it determined a refresh
+     * was needed. When provided, the manager compares it to the current cached
+     * value; if they differ, another caller already refreshed and the cached
+     * value is returned with no network round-trip. This bounds the refresh
+     * storm when many callers fail against the same stale value at once.
+     */
+    refresh(staleValue?: T): PromiseLike<T | undefined>;
+    /**
+     * Discards the cached resource. The next `get`/`refresh` fetches afresh.
+     * Intended for logout, org switch, and test teardown — not for routine
+     * staleness, which `refresh` handles non-destructively.
+     */
+    clear(): PromiseLike<void>;
+}

package/dist/v1/index.js

@@ -0,0 +1,48 @@
+class BasicRenewableResourceManager {
+  constructor(config) {
+    this.config = config;
+  }
+  get() {
+    return this.config.storage.get().then((cached) => cached !== void 0 ? cached : this.fetchAndStore());
+  }
+  refresh(staleValue) {
+    if (staleValue === void 0) {
+      return this.fetchAndStore();
+    }
+    return this.config.storage.get().then(
+      (current) => current !== void 0 && current !== staleValue ? current : this.fetchAndStore()
+    );
+  }
+  clear() {
+    return this.config.storage.clear();
+  }
+  /**
+   * Single in-flight fetch shared by all concurrent `get`/`refresh` callers.
+   * Overwrites storage on a successful fetch of a defined value only; a
+   * rejected fetch or a resolved-`undefined` leaves the cached value intact.
+   */
+  fetchAndStore() {
+    if (this.inFlightFetch) return this.inFlightFetch;
+    const pending = this.config.fetch().then(
+      (fetched) => fetched === void 0 ? fetched : this.config.storage.set(fetched).then(() => fetched)
+    );
+    this.inFlightFetch = pending;
+    const releaseSlot = () => {
+      if (this.inFlightFetch === pending) this.inFlightFetch = void 0;
+    };
+    pending.then(releaseSlot, releaseSlot);
+    return pending;
+  }
+}
+function buildRenewableResourceManagerDescriptor(type, service) {
+  return {
+    version: "1.0",
+    service,
+    type
+  };
+}
+export {
+  BasicRenewableResourceManager,
+  buildRenewableResourceManagerDescriptor
+};
+//# sourceMappingURL=index.js.map

package/dist/v1/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/v1/basic-renewable-resource-manager.ts","../../src/v1/index.ts"],"sourcesContent":["import type { RenewableResourceManager } from './renewable-resource-manager';\n\n/**\n * Storage adapter supplied by the runtime. Preconditions the manager relies on\n * but cannot enforce:\n *\n * - **Durable before resolution**: the `PromiseLike` returned by `set`/`clear`\n *   resolves only after the write is observable by a subsequent `get`.\n * - **Read-your-writes**: a `get` after a settled `set` observes that value.\n * - **Sole writer / monotonic replacement**: the manager is the only writer of\n *   this slot. The storm-dedup in {@link BasicRenewableResourceManager.refresh}\n *   treats \"stored value differs from the stale value\" as \"someone already\n *   refreshed\"; a third party mutating storage out from under the manager\n *   (e.g. a server-pushed value) breaks that assumption.\n */\nexport interface ResourceStorage<T> {\n    get: () => PromiseLike<T | undefined>;\n    set: (value: T) => PromiseLike<void>;\n    clear: () => PromiseLike<void>;\n}\n\nexport interface BasicRenewableResourceManagerConfig<T extends string | number | boolean> {\n    /** Fetches a fresh value from the source of truth (\"go to the network\"). */\n    fetch: () => PromiseLike<T | undefined>;\n    storage: ResourceStorage<T>;\n}\n\n/**\n * Configurable building block implementing {@link RenewableResourceManager}.\n *\n * The runtime supplies `fetch` and `storage`; the building block adds\n * single-flight fetch coalescing and refresh-storm deduplication. It holds no\n * opinion on storage backend, TTL, or initialization strategy — a consumer with\n * a preloaded value seeds `storage` before constructing the manager, so the\n * first `get` finds it and skips `fetch`.\n *\n * The implementation chains `PromiseLike` directly rather than using\n * `async`/`await` so a synchronous source stays synchronous and avoids a\n * microtask hop.\n */\nexport class BasicRenewableResourceManager<T extends string | number | boolean>\n    implements RenewableResourceManager<T>\n{\n    private inFlightFetch: PromiseLike<T | undefined> | undefined;\n\n    constructor(private readonly config: BasicRenewableResourceManagerConfig<T>) {}\n\n    get(): PromiseLike<T | undefined> {\n        return this.config.storage\n            .get()\n            .then((cached) => (cached !== undefined ? cached : this.fetchAndStore()));\n    }\n\n    refresh(staleValue?: T): PromiseLike<T | undefined> {\n        if (staleValue === undefined) {\n            return this.fetchAndStore();\n        }\n        // Storm dedup: if storage already holds a value other than the one this\n        // caller saw fail, another caller refreshed — return it, skip the network.\n        return this.config.storage\n            .get()\n            .then((current) =>\n                current !== undefined && current !== staleValue ? current : this.fetchAndStore()\n            );\n    }\n\n    clear(): PromiseLike<void> {\n        return this.config.storage.clear();\n    }\n\n    /**\n     * Single in-flight fetch shared by all concurrent `get`/`refresh` callers.\n     * Overwrites storage on a successful fetch of a defined value only; a\n     * rejected fetch or a resolved-`undefined` leaves the cached value intact.\n     */\n    private fetchAndStore(): PromiseLike<T | undefined> {\n        if (this.inFlightFetch) return this.inFlightFetch;\n\n        const pending = this.config\n            .fetch()\n            .then((fetched) =>\n                fetched === undefined\n                    ? fetched\n                    : this.config.storage.set(fetched).then(() => fetched)\n            );\n\n        // Assign the slot BEFORE attaching the release handler. PromiseLike\n        // resolves synchronously when fetch + set are synchronous, so the\n        // handler can run inline; if the assignment came after, releaseSlot\n        // would see `inFlightFetch === undefined`, no-op, and the slot set on\n        // the next line would leak forever.\n        this.inFlightFetch = pending;\n\n        const releaseSlot = () => {\n            if (this.inFlightFetch === pending) this.inFlightFetch = undefined;\n        };\n        pending.then(releaseSlot, releaseSlot);\n\n        return pending;\n    }\n}\n","import type { NamedService, ServiceDescriptor } from '@conduit-client/utils';\nimport type { RenewableResourceManager } from './renewable-resource-manager';\n\nexport type { RenewableResourceManager } from './renewable-resource-manager';\nexport {\n    BasicRenewableResourceManager,\n    type BasicRenewableResourceManagerConfig,\n    type ResourceStorage,\n} from './basic-renewable-resource-manager';\n\nexport type NamedRenewableResourceManagerService<Name extends string> = NamedService<\n    Name,\n    RenewableResourceManager<any>\n>;\n\nexport type RenewableResourceManagerServiceDescriptor<Name extends string> = ServiceDescriptor<\n    RenewableResourceManager<any>,\n    Name,\n    '1.0'\n>;\n\n/**\n * Builds a versioned service descriptor wrapping a {@link RenewableResourceManager}.\n *\n * The `type` is the resource name (e.g. `'csrfToken'`), so a runtime can\n * register multiple independent managers — one per renewable resource — each\n * resolvable by name through the provisioner.\n */\nexport function buildRenewableResourceManagerDescriptor<\n    Name extends string,\n    T extends string | number | boolean,\n>(\n    type: Name,\n    service: RenewableResourceManager<T>\n): RenewableResourceManagerServiceDescriptor<Name> {\n    return {\n        version: '1.0' as const,\n        service: service as RenewableResourceManager<any>,\n        type,\n    };\n}\n"],"names":[],"mappings":"AAwCO,MAAM,8BAEb;AAAA,EAGI,YAA6B,QAAgD;AAAhD,SAAA,SAAA;AAAA,EAAiD;AAAA,EAE9E,MAAkC;AAC9B,WAAO,KAAK,OAAO,QACd,IAAA,EACA,KAAK,CAAC,WAAY,WAAW,SAAY,SAAS,KAAK,eAAgB;AAAA,EAChF;AAAA,EAEA,QAAQ,YAA4C;AAChD,QAAI,eAAe,QAAW;AAC1B,aAAO,KAAK,cAAA;AAAA,IAChB;AAGA,WAAO,KAAK,OAAO,QACd,IAAA,EACA;AAAA,MAAK,CAAC,YACH,YAAY,UAAa,YAAY,aAAa,UAAU,KAAK,cAAA;AAAA,IAAc;AAAA,EAE3F;AAAA,EAEA,QAA2B;AACvB,WAAO,KAAK,OAAO,QAAQ,MAAA;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,gBAA4C;AAChD,QAAI,KAAK,cAAe,QAAO,KAAK;AAEpC,UAAM,UAAU,KAAK,OAChB,MAAA,EACA;AAAA,MAAK,CAAC,YACH,YAAY,SACN,UACA,KAAK,OAAO,QAAQ,IAAI,OAAO,EAAE,KAAK,MAAM,OAAO;AAAA,IAAA;AAQjE,SAAK,gBAAgB;AAErB,UAAM,cAAc,MAAM;AACtB,UAAI,KAAK,kBAAkB,QAAS,MAAK,gBAAgB;AAAA,IAC7D;AACA,YAAQ,KAAK,aAAa,WAAW;AAErC,WAAO;AAAA,EACX;AACJ;ACxEO,SAAS,wCAIZ,MACA,SAC+C;AAC/C,SAAO;AAAA,IACH,SAAS;AAAA,IACT;AAAA,IACA;AAAA,EAAA;AAER;"}

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@conduit-client/service-renewable-resource-manager",
+    "version": "3.22.0",
+    "private": false,
+    "description": "Generic renewable-resource manager service (lazy cache + single-flight fetch + refresh-storm dedup)",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/onestore.git",
+        "directory": "packages/@conduit-client/services/renewable-resource-manager"
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "exports": {
+        "./v1": {
+            "import": "./dist/v1/index.js",
+            "types": "./dist/types/v1/index.d.ts",
+            "require": "./dist/v1/index.js"
+        }
+    },
+    "main": "./dist/main/index.js",
+    "module": "./dist/main/index.js",
+    "types": "./dist/main/index.d.ts",
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build": "vite build && tsc --build --emitDeclarationOnly",
+        "clean": "rm -rf dist",
+        "test": "vitest run",
+        "test:size": "size-limit",
+        "watch": "npm run build --watch"
+    },
+    "dependencies": {
+        "@conduit-client/utils": "3.20.0"
+    },
+    "volta": {
+        "extends": "../../../../package.json"
+    },
+    "size-limit": [
+        {
+            "path": "./dist/v1/index.js",
+            "limit": "1 kB"
+        }
+    ]
+}