@qtsurfer/sdk 0.8.0 → 0.10.0

package/README.md

@@ -306,9 +306,43 @@ A verdict also describes the bytecode that existed when it was recorded. If `com
 than `validatedAt`, the strategy was recompiled afterwards and the verdict no longer describes what
 would run — ask for validation again.
 
+## Managing registered strategies
+
+```ts
+// Every strategy you've registered and not deleted, most recently compiled first.
+// Never 404s — an empty array means you have none.
+const summaries = await qts.strategies();
+
+// The exact source last submitted for an id, whitespace and comments included.
+const code = await qts.strategyCode(strategyId);
+
+// Release a registration.
+await qts.deleteStrategy(strategyId);
+```
+
+`strategies()` deliberately omits `validation` on every entry — that is what keeps it cheap
+regardless of how many strategies you have registered. Check a specific one's verdict with
+`strategy(strategyId)`.
+
+`strategyCode()`'s `404` covers two cases the response cannot tell apart: the id was never
+registered by you, or it resolves only through a shared/marketplace reference that carries no
+source of its own.
+
+`deleteStrategy()` resolves with nothing. It removes the strategy from both `strategy()` and
+`strategies()`, but does not undo anything already run: backtests you ran against it beforehand are
+unaffected, and re-submitting the exact same source afterwards registers a **new** strategy with a
+**new** id rather than undeleting this one. Deleting your own copy of a strategy never affects
+anyone else's copy of the same source (e.g. a shared/marketplace listing).
+
+A full `StrategyState` — from `strategy()`, and from `validateStrategy()`'s already-validated `200`
+— carries an optional `_links.code` discovery link pointing at the same source `strategyCode()`
+fetches by id. It is absent from `validateStrategy()`'s `queued: true` (`202`) outcome, which is a
+deliberately partial stub. The SDK does not follow this link for you; it passes through unmodified
+from api-client, so read it off `StrategyState` directly if you want it.
+
 ## API coverage
 
-Measured against **API spec 0.107.0**: 18 operations, all 18 reachable from this SDK.
+Measured against **API spec 0.109.2**: 21 operations, all 21 reachable from this SDK.
 
 It exists because the generated `@qtsurfer/api-client` tracks the spec automatically and this
 hand-written layer does not, so an operation the platform serves could otherwise have no way in
@@ -320,8 +354,9 @@ deliberately does not wrap it, the row says why.
 There are two ways an operation is reached:
 
 - **Direct** — callable on its own, without running a workflow. The client methods below
-  (`exchanges`, `instruments`, `tickers`, `klines`, `validateStrategy`, `strategy`) exist on
-  `QTSurfer` and, identically, on the authenticated session. The remaining direct rows are reached
+  (`exchanges`, `instruments`, `tickers`, `klines`, `validateStrategy`, `strategy`, `strategies`,
+  `deleteStrategy`, `strategyCode`) exist on `QTSurfer` and, identically, on the authenticated
+  session. The remaining direct rows are reached
   otherwise: `authenticate()` is a top-level export rather than a method on either class; the two
   `Sweep.*` entries live on the handle `sweep()` hands back and, being handle-scoped, sit outside
   the session's refresh-on-401 policy; and the two cancels are an option you pass in rather than a
@@ -341,9 +376,12 @@ There are two ways an operation is reached:
 | `listSegmentInstruments` | Direct — `instruments(exchangeId, segment)` |
 | `downloadTickers` | Direct — `tickers(...)` |
 | `downloadKlines` | Direct — `klines(...)` |
+| `listStrategies` | Direct — `strategies()` |
 | `compileStrategy` | Via workflow — inside `backtest(...)` / `sweep(...)`; no standalone method, unlike the Java SDK |
 | `validateStrategy` | Direct — `validateStrategy(strategyId)` |
 | `getStrategy` | Direct — `strategy(strategyId)` |
+| `deleteStrategy` | Direct — `deleteStrategy(strategyId)` |
+| `getStrategyCode` | Direct — `strategyCode(strategyId)` |
 | `prepareBacktest` | Via workflow |
 | `getPrepareStatus` | Via workflow |
 | `executeBacktest` | Via workflow — `backtest(...)` |

package/dist/index.d.ts

@@ -1,12 +1,43 @@
-import { ResultMap, Exchange as Exchange$1, InstrumentDetail as InstrumentDetail$1, StrategyState as StrategyState$1, SweepProgress as SweepProgress$1, ExecuteSweepAccepted, ExecuteSweepResult, SweepSensitivity as SweepSensitivity$1, SweepHeatmap as SweepHeatmap$1, SweepHeatmapCell as SweepHeatmapCell$1, SweepMarginal as SweepMarginal$1, SweepMarginalPoint as SweepMarginalPoint$1, SweepRunRow as SweepRunRow$1, WalkForwardFold as WalkForwardFold$1, WalkForwardResult as WalkForwardResult$1, AuthTokenResponse } from '@qtsurfer/api-client';
+import { ResultMap, Exchange as Exchange$1, InstrumentDetail as InstrumentDetail$1, StrategyState as StrategyState$1, StrategySummary as StrategySummary$1, SweepProgress as SweepProgress$1, ExecuteSweepAccepted, ExecuteSweepResult, SweepSensitivity as SweepSensitivity$1, SweepHeatmap as SweepHeatmap$1, SweepHeatmapCell as SweepHeatmapCell$1, SweepMarginal as SweepMarginal$1, SweepMarginalPoint as SweepMarginalPoint$1, SweepRunRow as SweepRunRow$1, WalkForwardFold as WalkForwardFold$1, WalkForwardResult as WalkForwardResult$1, AuthTokenResponse } from '@qtsurfer/api-client';
 
+/**
+ * ```ts
+ * const request: BacktestRequest = {
+ *   strategy: source,
+ *   exchangeId: 'binance',
+ *   instrument: 'BTC/USDT',
+ *   from: '2026-01-01T00:00:00Z',
+ *   to: '2026-02-01T00:00:00Z',
+ * };
+ * ```
+ *
+ * Backtest against a dataset you uploaded instead of an exchange instrument by
+ * replacing `instrument` with `datasetId` (and `exchangeId: 'user'`):
+ *
+ * ```ts
+ * const request: BacktestRequest = {
+ *   strategy: source,
+ *   exchangeId: 'user',
+ *   datasetId: 'ds_123',
+ *   from: '2026-01-01T00:00:00Z',
+ *   to: '2026-02-01T00:00:00Z',
+ * };
+ * ```
+ */
 interface BacktestRequest {
     /** Strategy source code (Java) */
     strategy: string;
-    /** Exchange id, e.g. `binance` */
+    /** Exchange id, e.g. `binance`, or the reserved value `user` when backtesting against `datasetId`. */
     exchangeId: string;
-    /** Instrument symbol, e.g. `BTC/USDT` */
-    instrument: string;
+    /** Instrument symbol, e.g. `BTC/USDT`. Exactly one of `instrument`/`datasetId` is required. */
+    instrument?: string;
+    /**
+     * Id of a dataset you uploaded, in place of `instrument`. Exactly one of
+     * `instrument`/`datasetId` is required. Pairs with `exchangeId: 'user'`.
+     */
+    datasetId?: string;
+    /** Optional specific version of `datasetId`; omit to use its current version. Requires `datasetId`. */
+    datasetVersionId?: string;
     /** Date range start (ISO-8601, ISO DATE or BASIC ISO DATE) */
     from: string;
     /** Date range end (same formats as `from`) */
@@ -96,6 +127,15 @@ type DownloadFormat = 'lastra' | 'parquet';
  * A verdict describes the bytecode that existed when it was recorded:
  * `compiledAt` newer than `validatedAt` means the strategy was recompiled
  * afterwards and the verdict no longer describes what would run.
+ *
+ * `_links.code`, when present, is a discovery link to this strategy's raw
+ * source (`GET /strategy/{strategyId}/code` — the same thing
+ * {@link QTSurfer.strategyCode} fetches by id, so there is no need to follow
+ * the link yourself). It is present on a full `StrategyState` body — this
+ * function's result, and {@link QTSurfer.validateStrategy}'s already-validated
+ * `200` — and **absent** from that same operation's `queued: true` (`202`)
+ * outcome, which is a deliberately partial stub. This field passes through
+ * unmodified from api-client, so it needs no unwrapping on the SDK's part.
  */
 type StrategyState = StrategyState$1;
 /**
@@ -120,6 +160,19 @@ type StrategyValidation = {
     strategyId: string;
     state?: undefined;
 };
+/**
+ * One entry in {@link QTSurfer.strategies}'s result: the same provenance
+ * {@link QTSurfer.strategy} reports — `compiledAt`, `requiredSources` — but
+ * never `validation`, which is what keeps listing cheap no matter how many
+ * strategies you have registered. Check a specific strategy's verdict with
+ * {@link QTSurfer.strategy}.
+ *
+ * Note: the spec types this endpoint's `requiredSources` as a plain
+ * `string[]`, not the `'Ticker' | 'KLine' | 'FundingRate'` union that
+ * {@link StrategyState}'s own `requiredSources` carries — narrow it yourself
+ * if you need the literal type. Alias for api-client's `StrategySummary`.
+ */
+type StrategySummary = StrategySummary$1;
 
 /**
  * The metric a sweep optimizes, and the one its leaderboard and its
@@ -351,14 +404,35 @@ type WalkForwardFold = WalkForwardFold$1;
  *   objective: 'sharpe',
  * };
  * ```
+ *
+ * Sweep against a dataset you uploaded instead of an exchange instrument by
+ * replacing `instrument` with `datasetId` (and `exchangeId: 'user'`):
+ *
+ * ```ts
+ * const request: SweepRequest = {
+ *   strategy: source,
+ *   exchangeId: 'user',
+ *   datasetId: 'ds_123',
+ *   from: '2026-01-01T00:00:00Z',
+ *   to: '2026-02-01T00:00:00Z',
+ *   params: { rsiPeriod: { from: 7, to: 28, step: 1 } },
+ * };
+ * ```
  */
 interface SweepRequest {
     /** Strategy source code (Java), compiled once and reused by every trial. */
     strategy: string;
-    /** Exchange id, e.g. `binance`. */
+    /** Exchange id, e.g. `binance`, or the reserved value `user` when sweeping against `datasetId`. */
     exchangeId: string;
-    /** Instrument symbol, e.g. `BTC/USDT`. */
-    instrument: string;
+    /** Instrument symbol, e.g. `BTC/USDT`. Exactly one of `instrument`/`datasetId` is required. */
+    instrument?: string;
+    /**
+     * Id of a dataset you uploaded, in place of `instrument`. Exactly one of
+     * `instrument`/`datasetId` is required. Pairs with `exchangeId: 'user'`.
+     */
+    datasetId?: string;
+    /** Optional specific version of `datasetId`; omit to use its current version. Requires `datasetId`. */
+    datasetVersionId?: string;
     /** Range start (ISO-8601, ISO DATE, or BASIC ISO DATE). */
     from: string;
     /** Range end (same formats as `from`; must be later than `from`). */
@@ -691,7 +765,7 @@ interface DownloadHourArgs {
  * Thin, stateless wrapper over `@qtsurfer/api-client` that exposes the SDK's
  * workflow methods (`backtest`, `sweep`, `tickers`, `klines`), the platform catalog
  * (`exchanges`, `instruments`) and the strategy surface (`validateStrategy`,
- * `strategy`). Constructing an
+ * `strategy`, `strategies`, `deleteStrategy`, `strategyCode`). Constructing an
  * instance reconfigures the underlying api-client singleton, so avoid
  * holding two `QTSurfer`s with different `baseUrl`s or tokens alive in the
  * same process — they will race. Prefer the `authenticate()` helper over
@@ -724,7 +798,8 @@ declare class QTSurfer {
      * if a stage exceeds `timeoutMs`, or {@link QTSCanceledError} if the caller's
      * signal fires before the sweep is accepted. A plain {@link QTSError} means
      * the request itself is malformed (an empty grid, a non-positive `step`, a
-     * walk-forward block with fewer than two folds) and never reached the network.
+     * walk-forward block with fewer than two folds, or naming both/neither of
+     * `instrument`/`datasetId`) and never reached the network.
      *
      * What the sweep *found* arrives through {@link Sweep.result}, which is also
      * where the semantics of the leaderboard are documented. Acceptance already
@@ -825,6 +900,42 @@ declare class QTSurfer {
      * It is never a stale or expired answer.
      */
     strategy(strategyId: string): Promise<StrategyState>;
+    /**
+     * List every strategy you have registered and not deleted, most recently
+     * compiled first. Never `404`s — an empty array means you have none.
+     * Each entry deliberately omits `validation`; check a specific strategy's
+     * verdict with {@link QTSurfer.strategy}. See {@link StrategySummary}.
+     *
+     * @throws QTSError on any non-2xx response, with the HTTP status on
+     * `status`.
+     */
+    strategies(): Promise<StrategySummary[]>;
+    /**
+     * Release a registered strategy: removes it from both {@link
+     * QTSurfer.strategy} and {@link QTSurfer.strategies}.
+     *
+     * Backtests already run against this strategy are unaffected, and
+     * re-submitting the same source afterwards registers a **new** strategy
+     * with a **new** id rather than undeleting this one. Deleting your own
+     * copy of a strategy never affects anyone else's copy of the same source
+     * (e.g. a shared/marketplace listing).
+     *
+     * @param strategyId the id returned when the strategy was compiled
+     * @throws QTSError on any non-2xx response; a `404` (carried on `status`)
+     * means no such registered strategy for this caller.
+     */
+    deleteStrategy(strategyId: string): Promise<void>;
+    /**
+     * Read back the exact source last submitted for a strategy id, whitespace
+     * and comments included.
+     *
+     * A `404` (carried on `status`) covers two indistinguishable cases: the id
+     * was never registered by you, or it resolves only through a shared/
+     * marketplace reference that carries no source of its own.
+     *
+     * @param strategyId the id returned when the strategy was compiled
+     */
+    strategyCode(strategyId: string): Promise<string>;
 }
 
 /**
@@ -1035,6 +1146,24 @@ declare class AuthenticatedClient {
      * a guarantee.
      */
     strategy(strategyId: string): Promise<StrategyState>;
+    /**
+     * List every strategy you have registered and not deleted, most recently
+     * compiled first. Refreshes the token once on `401` before retrying. See
+     * {@link QTSurfer.strategies}.
+     */
+    strategies(): Promise<StrategySummary[]>;
+    /**
+     * Release a registered strategy. Refreshes the token once on `401` before
+     * retrying. See {@link QTSurfer.deleteStrategy} for what this does and
+     * does not undo.
+     */
+    deleteStrategy(strategyId: string): Promise<void>;
+    /**
+     * Read back a strategy's exact registered source. Refreshes the token
+     * once on `401` before retrying. See {@link QTSurfer.strategyCode} for
+     * what its `404` covers.
+     */
+    strategyCode(strategyId: string): Promise<string>;
 }
 /**
  * Exchange a long-lived API key for an authenticated session.
@@ -1043,10 +1172,11 @@ declare class AuthenticatedClient {
  * environment. The returned {@link AuthenticatedClient} caches the JWT,
  * refreshes it on 401, and exposes the same surface as `QTSurfer`
  * (`backtest`, `sweep`, `tickers`, `klines`, `exchanges`, `instruments`,
- * `validateStrategy`, `strategy`).
+ * `validateStrategy`, `strategy`, `strategies`, `deleteStrategy`,
+ * `strategyCode`).
  *
  * @throws {QTSAuthError} if no apikey is supplied or available in env.
  */
 declare function authenticate(apikey?: string, opts?: AuthOptions): Promise<AuthenticatedClient>;
 
-export { type AuthOptions, AuthenticatedClient, type BacktestOptions, type BacktestProgress, type BacktestRequest, type BacktestResult, type BacktestStage, type DownloadFormat, type DownloadHourArgs, type Exchange, InMemoryTokenStore, type InstrumentDetail, type InstrumentSegment, type ParamAxis, QTSAuthError, QTSCanceledError, QTSDownloadError, QTSError, QTSExecutionError, QTSPreparationError, QTSStrategyCompileError, QTSTimeoutError, QTSurfer, type QTSurferOptions, type StrategyState, type StrategyValidation, type Sweep, type SweepAccepted, type SweepHeatmap, type SweepHeatmapCell, type SweepMarginal, type SweepMarginalPoint, type SweepObjective, type SweepOptions, type SweepOrder, type SweepProgress, type SweepProgressEvent, type SweepRanking, type SweepRequest, type SweepResult, type SweepRunRow, type SweepSampler, type SweepSensitivity, type SweepState, type SweepWalkForward, type TokenStore, type WalkForwardFold, type WalkForwardResult, authenticate };
+export { type AuthOptions, AuthenticatedClient, type BacktestOptions, type BacktestProgress, type BacktestRequest, type BacktestResult, type BacktestStage, type DownloadFormat, type DownloadHourArgs, type Exchange, InMemoryTokenStore, type InstrumentDetail, type InstrumentSegment, type ParamAxis, QTSAuthError, QTSCanceledError, QTSDownloadError, QTSError, QTSExecutionError, QTSPreparationError, QTSStrategyCompileError, QTSTimeoutError, QTSurfer, type QTSurferOptions, type StrategyState, type StrategySummary, type StrategyValidation, type Sweep, type SweepAccepted, type SweepHeatmap, type SweepHeatmapCell, type SweepMarginal, type SweepMarginalPoint, type SweepObjective, type SweepOptions, type SweepOrder, type SweepProgress, type SweepProgressEvent, type SweepRanking, type SweepRequest, type SweepResult, type SweepRunRow, type SweepSampler, type SweepSensitivity, type SweepState, type SweepWalkForward, type TokenStore, type WalkForwardFold, type WalkForwardResult, authenticate };

package/dist/index.js

@@ -145,10 +145,31 @@ async function compileStrategySource(source, signal) {
   }
   return data.strategyId;
 }
+function validatePrepareTarget(workflow, target) {
+  const hasInstrument = target.instrument !== void 0;
+  const hasDataset = target.datasetId !== void 0;
+  if (hasInstrument && hasDataset) {
+    throw new QTSError(`${workflow}: exactly one of instrument/datasetId is required, got both`);
+  }
+  if (!hasInstrument && !hasDataset) {
+    throw new QTSError(
+      `${workflow}: exactly one of instrument/datasetId is required, got neither`
+    );
+  }
+  if (target.datasetVersionId !== void 0 && !hasDataset) {
+    throw new QTSError(`${workflow}: datasetVersionId requires datasetId`);
+  }
+}
 async function prepareDataset(target, policy, run = {}) {
   const { data, error } = await prepareBacktest({
     path: { exchangeId: target.exchangeId, type: TICKER },
-    body: { instrument: target.instrument, from: target.from, to: target.to },
+    body: {
+      ...target.instrument !== void 0 ? { instrument: target.instrument } : {},
+      ...target.datasetId !== void 0 ? { datasetId: target.datasetId } : {},
+      ...target.datasetVersionId !== void 0 ? { datasetVersionId: target.datasetVersionId } : {},
+      from: target.from,
+      to: target.to
+    },
     ...run.signal ? { signal: run.signal } : {}
   });
   if (error) throw new QTSPreparationError("Prepare submission failed", error);
@@ -188,6 +209,7 @@ async function prepareDataset(target, policy, run = {}) {
 var DEFAULT_POLL_INTERVAL_MS = 500;
 var DEFAULT_MAX_POLL_INTERVAL_MS = 5e3;
 async function backtest(req, opts = {}) {
+  validatePrepareTarget("backtest", req);
   const policy = buildStagePolicy(opts, DEFAULT_POLL_INTERVAL_MS, DEFAULT_MAX_POLL_INTERVAL_MS);
   opts.onProgress?.({ stage: "compiling" });
   const strategyId = await compileStrategySource(req.strategy, opts.signal);
@@ -200,7 +222,9 @@ function prepareData(req, policy, opts) {
   return prepareDataset(
     {
       exchangeId: req.exchangeId,
-      instrument: req.instrument,
+      ...req.instrument !== void 0 ? { instrument: req.instrument } : {},
+      ...req.datasetId !== void 0 ? { datasetId: req.datasetId } : {},
+      ...req.datasetVersionId !== void 0 ? { datasetVersionId: req.datasetVersionId } : {},
       from: req.from,
       to: req.to
     },
@@ -360,7 +384,10 @@ function describe2(error) {
 // src/workflows/strategies.ts
 import {
   getStrategy as apiGetStrategy,
-  validateStrategy as apiValidateStrategy
+  validateStrategy as apiValidateStrategy,
+  listStrategies as apiListStrategies,
+  deleteStrategy as apiDeleteStrategy,
+  getStrategyCode as apiGetStrategyCode
 } from "@qtsurfer/api-client";
 async function validateStrategy(strategyId) {
   const { data, error, response } = await apiValidateStrategy({ path: { strategyId } });
@@ -375,6 +402,22 @@ async function getStrategy(strategyId) {
   if (!data) throw new QTSError("Empty strategy response");
   return data;
 }
+async function listStrategies() {
+  const { data, error, response } = await apiListStrategies();
+  if (error) throw requestFailed("strategies list", error, response?.status);
+  if (!data) throw new QTSError("Empty strategies response");
+  return data.strategies;
+}
+async function deleteStrategy(strategyId) {
+  const { error, response } = await apiDeleteStrategy({ path: { strategyId } });
+  if (error) throw requestFailed("strategy delete", error, response?.status);
+}
+async function getStrategyCode(strategyId) {
+  const { data, error, response } = await apiGetStrategyCode({ path: { strategyId } });
+  if (error) throw requestFailed("strategy code lookup", error, response?.status);
+  if (!data) throw new QTSError("Empty strategy code response");
+  return data.code;
+}
 
 // src/workflows/sweep.ts
 import {
@@ -403,6 +446,7 @@ async function sweep(req, opts = {}) {
   return createHandle(req, opts, policy, data, requestId, strategyId);
 }
 function validateRequest(req) {
+  validatePrepareTarget("sweep", req);
   const names = Object.keys(req.params ?? {});
   if (names.length === 0) {
     throw new QTSError("sweep: params must hold at least one axis");
@@ -432,7 +476,9 @@ function prepareData2(req, policy, opts) {
   return prepareDataset(
     {
       exchangeId: req.exchangeId,
-      instrument: req.instrument,
+      ...req.instrument !== void 0 ? { instrument: req.instrument } : {},
+      ...req.datasetId !== void 0 ? { datasetId: req.datasetId } : {},
+      ...req.datasetVersionId !== void 0 ? { datasetVersionId: req.datasetVersionId } : {},
       from: req.from,
       to: req.to
     },
@@ -593,7 +639,8 @@ var QTSurfer = class {
    * if a stage exceeds `timeoutMs`, or {@link QTSCanceledError} if the caller's
    * signal fires before the sweep is accepted. A plain {@link QTSError} means
    * the request itself is malformed (an empty grid, a non-positive `step`, a
-   * walk-forward block with fewer than two folds) and never reached the network.
+   * walk-forward block with fewer than two folds, or naming both/neither of
+   * `instrument`/`datasetId`) and never reached the network.
    *
    * What the sweep *found* arrives through {@link Sweep.result}, which is also
    * where the semantics of the leaderboard are documented. Acceptance already
@@ -708,6 +755,48 @@ var QTSurfer = class {
   strategy(strategyId) {
     return getStrategy(strategyId);
   }
+  /**
+   * List every strategy you have registered and not deleted, most recently
+   * compiled first. Never `404`s — an empty array means you have none.
+   * Each entry deliberately omits `validation`; check a specific strategy's
+   * verdict with {@link QTSurfer.strategy}. See {@link StrategySummary}.
+   *
+   * @throws QTSError on any non-2xx response, with the HTTP status on
+   * `status`.
+   */
+  strategies() {
+    return listStrategies();
+  }
+  /**
+   * Release a registered strategy: removes it from both {@link
+   * QTSurfer.strategy} and {@link QTSurfer.strategies}.
+   *
+   * Backtests already run against this strategy are unaffected, and
+   * re-submitting the same source afterwards registers a **new** strategy
+   * with a **new** id rather than undeleting this one. Deleting your own
+   * copy of a strategy never affects anyone else's copy of the same source
+   * (e.g. a shared/marketplace listing).
+   *
+   * @param strategyId the id returned when the strategy was compiled
+   * @throws QTSError on any non-2xx response; a `404` (carried on `status`)
+   * means no such registered strategy for this caller.
+   */
+  deleteStrategy(strategyId) {
+    return deleteStrategy(strategyId);
+  }
+  /**
+   * Read back the exact source last submitted for a strategy id, whitespace
+   * and comments included.
+   *
+   * A `404` (carried on `status`) covers two indistinguishable cases: the id
+   * was never registered by you, or it resolves only through a shared/
+   * marketplace reference that carries no source of its own.
+   *
+   * @param strategyId the id returned when the strategy was compiled
+   */
+  strategyCode(strategyId) {
+    return getStrategyCode(strategyId);
+  }
   // Future surface:
   //   TTL cache for exchanges / instruments
   //   jobs: { cancel, stream, result }
@@ -896,6 +985,30 @@ var AuthenticatedClient = class {
   strategy(strategyId) {
     return this.withRefreshOn401(() => getStrategy(strategyId));
   }
+  /**
+   * List every strategy you have registered and not deleted, most recently
+   * compiled first. Refreshes the token once on `401` before retrying. See
+   * {@link QTSurfer.strategies}.
+   */
+  strategies() {
+    return this.withRefreshOn401(() => listStrategies());
+  }
+  /**
+   * Release a registered strategy. Refreshes the token once on `401` before
+   * retrying. See {@link QTSurfer.deleteStrategy} for what this does and
+   * does not undo.
+   */
+  deleteStrategy(strategyId) {
+    return this.withRefreshOn401(() => deleteStrategy(strategyId));
+  }
+  /**
+   * Read back a strategy's exact registered source. Refreshes the token
+   * once on `401` before retrying. See {@link QTSurfer.strategyCode} for
+   * what its `404` covers.
+   */
+  strategyCode(strategyId) {
+    return this.withRefreshOn401(() => getStrategyCode(strategyId));
+  }
 };
 async function authenticate(apikey, opts = {}) {
   const resolved = apikey ?? readEnvApikey();