@bedrock-rbx/ocale 0.1.0-beta.9 → 0.1.0

package/dist/retry-r1TXe5Zd.d.mts

@@ -0,0 +1,189 @@
+import { d as OpenCloudError } from "./types-CRiJg5EQ.mjs";
+
+//#region src/errors/api-error.d.ts
+/**
+* Options for constructing an {@link ApiError}.
+*
+* @since 0.1.0
+*/
+interface ApiErrorOptions extends ErrorOptions {
+  /** Optional machine-readable error code from the API. */
+  code?: string | undefined;
+  /** Parsed response body, when present. */
+  details?: JSONValue | undefined;
+  /** HTTP status code from the API response. */
+  statusCode: number;
+}
+/**
+* Thrown when the Roblox Open Cloud API returns a non-2xx response
+* that is not a rate limit (429).
+*
+* @since 0.1.0
+*
+* @example
+*
+* ```ts
+* import { ApiError } from "@bedrock-rbx/ocale";
+*
+* const error = new ApiError("HTTP 404: Pass not found (code NotFound)", {
+*     code: "NotFound",
+*     details: { errorCode: "NotFound", message: "Pass not found" },
+*     statusCode: 404,
+* });
+*
+* expect(error).toBeInstanceOf(ApiError);
+* expect(error.statusCode).toBe(404);
+* expect(error.code).toBe("NotFound");
+* expect(error.details).toEqual({
+*     errorCode: "NotFound",
+*     message: "Pass not found",
+* });
+* ```
+*/
+declare class ApiError extends OpenCloudError {
+  readonly code: string | undefined;
+  readonly details: JSONValue | undefined;
+  override readonly name: string;
+  readonly statusCode: number;
+  /**
+  * Creates a new ApiError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including status code, optional error
+  *   code, and the parsed response body when present.
+  */
+  constructor(message: string, options: ApiErrorOptions);
+}
+//#endregion
+//#region src/errors/network-error.d.ts
+/**
+* Options for constructing a {@link NetworkError}.
+*
+* @since 0.1.0
+*/
+interface NetworkErrorOptions extends ErrorOptions {
+  /** HTTP method of the request that failed. */
+  method?: string | undefined;
+  /** Fully-qualified URL of the request that failed. */
+  url?: string | undefined;
+}
+/**
+* Thrown when a network-level failure prevents the request from reaching
+* the Roblox Open Cloud API (e.g., DNS resolution failure, connection reset).
+* The `method` and `url` name the failing call so a transport failure that
+* survives every retry can be diagnosed; the underlying transport error is
+* carried on `cause`.
+*
+* @since 0.1.0
+*/
+declare class NetworkError extends OpenCloudError {
+  readonly method: string | undefined;
+  override readonly name: string;
+  readonly url: string | undefined;
+  /**
+  * Creates a new NetworkError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including the optional `cause` and the
+  *   `method` / `url` of the request that failed.
+  */
+  constructor(message: string, options?: NetworkErrorOptions);
+}
+//#endregion
+//#region src/errors/rate-limit.d.ts
+/**
+* Options for constructing a {@link RateLimitError}.
+*
+* @since 0.1.0
+*/
+interface RateLimitErrorOptions extends ErrorOptions {
+  /**
+  * Requests still allowed in the throttled window, read from
+  * `x-ratelimit-remaining` (the most-constrained window). `undefined` when
+  * the header is absent or carries no finite numeric token; parsed
+  * independently of `x-ratelimit-reset`, so a valid value survives a
+  * non-numeric reset. Typically `0` on a genuine 429.
+  */
+  remaining?: number | undefined;
+  /** Seconds to wait before retrying the request. */
+  retryAfterSeconds: number;
+}
+/**
+* Thrown when the Roblox Open Cloud API returns a 429 Too Many Requests response.
+* Contains the server-suggested retry delay.
+*
+* @since 0.1.0
+*
+* @example
+*
+* ```ts
+* import { RateLimitError } from "@bedrock-rbx/ocale";
+*
+* const error = new RateLimitError("Too many requests", {
+*     retryAfterSeconds: 30,
+* });
+*
+* expect(error).toBeInstanceOf(RateLimitError);
+* expect(error.retryAfterSeconds).toBe(30);
+* ```
+*/
+declare class RateLimitError extends OpenCloudError {
+  override readonly name = "RateLimitError";
+  /** Requests left in the throttled window, or `undefined` if not reported. */
+  readonly remaining: number | undefined;
+  readonly retryAfterSeconds: number;
+  /**
+  * Creates a new RateLimitError.
+  *
+  * @param message - Human-readable error description.
+  * @param options - Error options including the retry delay.
+  */
+  constructor(message: string, options: RateLimitErrorOptions);
+}
+//#endregion
+//#region src/internal/http/retry.d.ts
+/**
+* Fully-resolved retry config shape that {@link mergeConfig} and
+* {@link shouldRetry} operate on. Fields are required because this represents
+* the post-defaulting, internal view; callers should supply every field (or
+* resolve them via a test factory / client constructor). The partial,
+* user-facing type lives on client construction options; method defaults and
+* per-request overrides use `Partial<RetryResolvable>`.
+*/
+interface RetryResolvable {
+  /** Roblox Open Cloud API key. */
+  readonly apiKey: string;
+  /** Base URL for the Open Cloud API. */
+  readonly baseUrl: string;
+  /** Maximum retry attempts before giving up. */
+  readonly maxRetries: number;
+  /** Status codes that are eligible for retry. */
+  readonly retryableStatuses: ReadonlyArray<number>;
+  /**
+  * Node-style transport error codes ({@link findErrorCode}) eligible for
+  * retry when surfaced as a {@link NetworkError}. Empty for create
+  * operations by default; consumers opt a create in via a per-request
+  * override.
+  */
+  readonly retryableTransportCodes: ReadonlyArray<string>;
+  /** Fallback delay function when no server hint is available. */
+  readonly retryDelay: (attempt: number) => number;
+  /** Per-request timeout in milliseconds. */
+  readonly timeout: number;
+}
+/**
+* Transient transport error codes that are safe to retry for idempotent
+* operations. Connection resets, timeouts, and DNS hiccups are recoverable on
+* a retry. A self-aborted request timeout carries no OS-level `code`, so
+* {@link shouldRetry} folds it into this set as `ETIMEDOUT` (via
+* {@link isTimeoutAbort}) for idempotent methods; create methods retry no
+* transport codes and so still never re-issue a timed-out write.
+*
+* @since 0.1.0
+*/
+declare const TRANSIENT_TRANSPORT_CODES: ReadonlyArray<string>;
+/** Kind of HTTP method the merge is being performed for. */
+type MethodKind = "create" | "idempotent";
+//#endregion
+export { RateLimitErrorOptions as a, ApiError as c, RateLimitError as i, ApiErrorOptions as l, RetryResolvable as n, NetworkError as o, TRANSIENT_TRANSPORT_CODES as r, NetworkErrorOptions as s, MethodKind as t };
+//# sourceMappingURL=retry-r1TXe5Zd.d.mts.map

package/dist/retry-r1TXe5Zd.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-r1TXe5Zd.d.mts","names":[],"sources":["../src/errors/api-error.ts","../src/errors/network-error.ts","../src/errors/rate-limit.ts","../src/internal/http/retry.ts"],"mappings":";;;;;AAOA;;;UAAiB,eAAA,SAAwB,YAAA;;EAExC,IAAA;;EAEA,OAAA,GAAU,SAAA;;EAEV,UAAA;AAAA;AA6BD;;;;;;;;;;;;;;;;;;;AAauC;;;;AChDvC;;;ADmCA,cAAa,QAAA,SAAiB,cAAA;EAAA,SACb,IAAA;EAAA,SACA,OAAA,EAAS,SAAA;EAAA,kBACA,IAAA;EAAA,SACT,UAAA;ECnChB;AAYD;;;;;;EDgCC,WAAA,CAAY,OAAA,UAAiB,OAAA,EAAS,eAAA;AAAA;;;;;AAhDvC;;;UCAiB,mBAAA,SAA4B,YAAA;;EAE5C,MAAA;;EAEA,GAAA;AAAA;;ADEA;AA6BD;;;;;;;cCnBa,YAAA,SAAqB,cAAA;EAAA,SACjB,MAAA;EAAA,kBACS,IAAA;EAAA,SACT,GAAA;;;;;;;;EAShB,WAAA,CAAY,OAAA,UAAiB,OAAA,GAAU,mBAAA;AAAA;;;;;AD5BxC;;;UEAiB,qBAAA,SAA8B,YAAA;;;;;;;AFM9C;EEEA,SAAA;EF2BY;EEzBZ,iBAAA;AAAA;;;;;;;;;;;;;;;;AFsCsC;;;;cEhB1B,cAAA,SAAuB,cAAA;EAAA,kBACV,IAAA;;WAET,SAAA;EAAA,SACA,iBAAA;;;;ADhChB;AAYD;;EC4BC,WAAA,CAAY,OAAA,UAAiB,OAAA,EAAS,qBAAA;AAAA;;;AF5CvC;;;;;;;;AAAA,UGMiB,eAAA;EHAhB;EAAA,SGES,MAAA;EH2BV;EAAA,SGzBU,OAAA;;WAEA,UAAA;;WAEA,iBAAA,EAAmB,aAAA;EHqBC;;;;;;EAAA,SGdpB,uBAAA,EAAyB,aAAA;;WAEzB,UAAA,GAAa,OAAA;;WAEb,OAAA;AAAA;;AHuB6B;;;;AChDvC;;;;;cEsCa,yBAAA,EAA2B,aAAA;;KAsC5B,UAAA"}

package/dist/{signatures-B5Fojgn0.mjs → signatures-JF-7Psce.mjs}

@@ -56,4 +56,4 @@ function matchesSignature(body, signature) {
 //#endregion
 export { RBXL_SIGNATURE as n, matchesSignature as r, RBXLX_SIGNATURE as t };
 
-//# sourceMappingURL=signatures-B5Fojgn0.mjs.map
+//# sourceMappingURL=signatures-JF-7Psce.mjs.map

package/dist/{signatures-B5Fojgn0.mjs.map → signatures-JF-7Psce.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"signatures-B5Fojgn0.mjs","names":[],"sources":["../src/domains/universes/places/signatures.ts"],"sourcesContent":["/**\n * Magic-byte prefix every Roblox binary place file (`.rbxl`) starts with.\n * The first 8 bytes spell out `<roblox!` in ASCII; the remaining 6 bytes\n * (`\\x89\\xff\\r\\n\\x1a\\n`) are the binary-format marker that distinguishes a\n * binary place file from the XML form (`.rbxlx`), whose ASCII-only header\n * begins with `<roblox `.\n */\nexport const RBXL_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a, 0x0a,\n]);\n\n/**\n * Magic-byte prefix every Roblox XML place file (`.rbxlx`) starts with.\n * Equivalent to the ASCII string `<roblox ` (note the trailing space): a\n * well-formed rbxlx file opens with `<roblox` followed by attributes, while\n * an rbxl file uses `<roblox!` (exclamation mark) as the eighth byte. The\n * trailing space is what proves the file is the XML variant rather than\n * the binary one.\n */\nexport const RBXLX_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x20,\n]);\n\n/**\n * Reports whether `body` begins with `signature`. A pure byte-prefix check\n * with no allocation; used by the place builder to disambiguate `.rbxl` and\n * `.rbxlx` payloads against their declared `format`.\n *\n * @param body - The caller-supplied place file bytes.\n * @param signature - One of the frozen signature constants from this module.\n * @returns `true` if every byte of `signature` matches `body[0..signature.length]`.\n */\nexport function matchesSignature(\n\tbody: Uint8Array,\n\tsignature: Readonly<Uint8Array<ArrayBuffer>>,\n): boolean {\n\tfor (const [index, expected] of signature.entries()) {\n\t\tif (body[index] !== expected) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,iBAAoD,IAAI,WAAW;CAC/E;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAC9E,CAAC;;;;;;;;;AAUF,MAAa,kBAAqD,IAAI,WAAW;CAChF;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAC1C,CAAC;;;;;;;;;;AAWF,SAAgB,iBACf,MACA,WACU;AACV,MAAK,MAAM,CAAC,OAAO,aAAa,UAAU,SAAS,CAClD,KAAI,KAAK,WAAW,SACnB,QAAO;AAIT,QAAO"}
+{"version":3,"file":"signatures-JF-7Psce.mjs","names":[],"sources":["../src/domains/universes/places/signatures.ts"],"sourcesContent":["/**\n * Magic-byte prefix every Roblox binary place file (`.rbxl`) starts with.\n * The first 8 bytes spell out `<roblox!` in ASCII; the remaining 6 bytes\n * (`\\x89\\xff\\r\\n\\x1a\\n`) are the binary-format marker that distinguishes a\n * binary place file from the XML form (`.rbxlx`), whose ASCII-only header\n * begins with `<roblox `.\n */\nexport const RBXL_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x21, 0x89, 0xff, 0x0d, 0x0a, 0x1a, 0x0a,\n]);\n\n/**\n * Magic-byte prefix every Roblox XML place file (`.rbxlx`) starts with.\n * Equivalent to the ASCII string `<roblox ` (note the trailing space): a\n * well-formed rbxlx file opens with `<roblox` followed by attributes, while\n * an rbxl file uses `<roblox!` (exclamation mark) as the eighth byte. The\n * trailing space is what proves the file is the XML variant rather than\n * the binary one.\n */\nexport const RBXLX_SIGNATURE: Readonly<Uint8Array<ArrayBuffer>> = new Uint8Array([\n\t0x3c, 0x72, 0x6f, 0x62, 0x6c, 0x6f, 0x78, 0x20,\n]);\n\n/**\n * Reports whether `body` begins with `signature`. A pure byte-prefix check\n * with no allocation; used by the place builder to disambiguate `.rbxl` and\n * `.rbxlx` payloads against their declared `format`.\n *\n * @param body - The caller-supplied place file bytes.\n * @param signature - One of the frozen signature constants from this module.\n * @returns `true` if every byte of `signature` matches `body[0..signature.length]`.\n */\nexport function matchesSignature(\n\tbody: Uint8Array,\n\tsignature: Readonly<Uint8Array<ArrayBuffer>>,\n): boolean {\n\tfor (const [index, expected] of signature.entries()) {\n\t\tif (body[index] !== expected) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,iBAAoD,IAAI,WAAW;CAC/E;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;AAC/E,CAAC;;;;;;;;;AAUD,MAAa,kBAAqD,IAAI,WAAW;CAChF;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;CAAM;AAC3C,CAAC;;;;;;;;;;AAWD,SAAgB,iBACf,MACA,WACU;CACV,KAAK,MAAM,CAAC,OAAO,aAAa,UAAU,QAAQ,GACjD,IAAI,KAAK,WAAW,UACnB,OAAO;CAIT,OAAO;AACR"}

package/dist/storage.d.mts

@@ -1,9 +1,12 @@
-import { d as OpenCloudError, i as OpenCloudClientOptions, l as Result, n as HttpRequest, r as HttpResponse, s as RequestOptions, u as SleepFunc } from "./types-CwtZT1ek.mjs";
+import { d as OpenCloudError, i as OpenCloudClientOptions, l as Result, n as HttpRequest, r as HttpResponse, s as RequestOptions, u as SleepFunc } from "./types-CRiJg5EQ.mjs";
+import { n as RetryResolvable, t as MethodKind } from "./retry-r1TXe5Zd.mjs";
 
 //#region src/domains/cloud-v2/memory-store-queues/types.d.ts
 /**
 * Caller-supplied input for the `enqueue` method on `StorageClient.queues`.
 * Mirrors `Cloud_CreateMemoryStoreQueueItem` on the Open Cloud API.
+*
+* @since 0.1.0
 */
 interface EnqueueQueueItemParameters {
   /**
@@ -34,6 +37,8 @@ interface EnqueueQueueItemParameters {
 * Parsed representation of a memory-store queue item, as returned by the
 * Open Cloud `Cloud_CreateMemoryStoreQueueItem` and (inside the array)
 * `Cloud_ReadMemoryStoreQueueItems` endpoints.
+*
+* @since 0.1.0
 */
 interface QueueItem {
   /** Server-generated item identifier, parsed from the wire `path`. */
@@ -55,6 +60,8 @@ interface QueueItem {
 /**
 * Caller-supplied input for the `dequeue` method on
 * `StorageClient.queues`. Mirrors `Cloud_ReadMemoryStoreQueueItems`.
+*
+* @since 0.1.0
 */
 interface DequeueQueueItemsParameters {
   /**
@@ -84,6 +91,8 @@ interface DequeueQueueItemsParameters {
 * response. The `readId` value must be passed to a subsequent
 * `discard` call to acknowledge the items; otherwise the items reappear
 * once the invisibility window elapses.
+*
+* @since 0.1.0
 */
 interface DequeueResult {
   /** Items dequeued from the front of the queue, in dequeue order. */
@@ -100,6 +109,8 @@ interface DequeueResult {
 * Acknowledging a `readId` removes the dequeued batch from the queue
 * permanently; without `discard`, the items reappear once their
 * invisibility window elapses.
+*
+* @since 0.1.0
 */
 interface DiscardQueueItemsParameters {
   /** Stringified queue identifier. */
@@ -116,6 +127,8 @@ interface DiscardQueueItemsParameters {
 * server contract requires at most one of `stringSortKey` or
 * `numericSortKey`; the union surfaces that constraint at the type
 * level so callers cannot accidentally set both.
+*
+* @since 0.1.0
 */
 type SortKey = {
   readonly kind: "numeric";
@@ -128,6 +141,8 @@ type SortKey = {
 * Caller-supplied input for the `create` method on
 * `StorageClient.sortedMaps`. Mirrors
 * `Cloud_CreateMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
 */
 interface CreateSortedMapItemParameters {
   /**
@@ -159,6 +174,8 @@ interface CreateSortedMapItemParameters {
 * `Cloud_ListMemoryStoreSortedMapItems` on the Open Cloud API. All
 * paging and filtering parameters are optional; omitting them returns
 * up to one item server-side (`maxPageSize` defaults to `1`).
+*
+* @since 0.1.0
 */
 interface ListSortedMapItemsParameters {
   /**
@@ -190,6 +207,8 @@ interface ListSortedMapItemsParameters {
 /**
 * Parsed representation of a sorted-map item, as returned by every
 * sorted-map operation that yields a single item.
+*
+* @since 0.1.0
 */
 interface SortedMapItem {
   /** Item identifier, parsed from the wire `path`. */
@@ -221,6 +240,8 @@ interface SortedMapItem {
 /**
 * Parsed result of a successful `Cloud_ListMemoryStoreSortedMapItems`
 * response.
+*
+* @since 0.1.0
 */
 interface ListSortedMapItemsResult {
   /** Items returned in the current page, ordered per `orderBy`. */
@@ -235,6 +256,8 @@ interface ListSortedMapItemsResult {
 * Caller-supplied input for the `delete` method on
 * `StorageClient.sortedMaps`. Mirrors
 * `Cloud_DeleteMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
 */
 interface DeleteSortedMapItemParameters {
   /** Caller-supplied item identifier. URL-encoded by the builder. */
@@ -248,6 +271,8 @@ interface DeleteSortedMapItemParameters {
 * Caller-supplied input for the `get` method on
 * `StorageClient.sortedMaps`. Mirrors
 * `Cloud_GetMemoryStoreSortedMapItem` on the Open Cloud API.
+*
+* @since 0.1.0
 */
 interface GetSortedMapItemParameters {
   /** Caller-supplied item identifier. URL-encoded by the builder. */
@@ -263,6 +288,8 @@ interface GetSortedMapItemParameters {
 * `Cloud_UpdateMemoryStoreSortedMapItem` on the Open Cloud API. Body
 * fields (`value`, `ttl`, `sortKey`) are optional under PATCH
 * semantics; omitted fields are left unchanged on the server.
+*
+* @since 0.1.0
 */
 interface UpdateSortedMapItemParameters {
   /**
@@ -308,32 +335,6 @@ interface OperationLimit {
   readonly operationKey: string;
 }
 //#endregion
-//#region src/internal/http/retry.d.ts
-/**
-* Fully-resolved retry config shape that {@link mergeConfig} and
-* {@link shouldRetry} operate on. Fields are required because this represents
-* the post-defaulting, internal view — callers should supply every field (or
-* resolve them via a test factory / client constructor). The partial,
-* user-facing type lives on client construction options; method defaults and
-* per-request overrides use `Partial<RetryResolvable>`.
-*/
-interface RetryResolvable {
-  /** Roblox Open Cloud API key. */
-  readonly apiKey: string;
-  /** Base URL for the Open Cloud API. */
-  readonly baseUrl: string;
-  /** Maximum retry attempts before giving up. */
-  readonly maxRetries: number;
-  /** Status codes that are eligible for retry. */
-  readonly retryableStatuses: ReadonlyArray<number>;
-  /** Fallback delay function when no server hint is available. */
-  readonly retryDelay: (attempt: number) => number;
-  /** Per-request timeout in milliseconds. */
-  readonly timeout: number;
-}
-/** Kind of HTTP method the merge is being performed for. */
-type MethodKind = "create" | "idempotent";
-//#endregion
 //#region src/internal/resource-client.d.ts
 /**
 * Describes a single resource method's shape for dispatch through
@@ -635,6 +636,8 @@ declare class MemoryStoreSortedMapsGroup {
 * Every method returns a `Result` so callers handle failure
 * explicitly; no thrown error ever escapes the client.
 *
+* @since 0.1.0
+*
 * @example
 *
 * ```ts

package/dist/storage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.d.mts","names":[],"sources":["../src/domains/cloud-v2/memory-store-queues/types.ts","../src/domains/cloud-v2/memory-store-sorted-maps/types.ts","../src/internal/http/rate-limit-queue.ts","../src/internal/http/retry.ts","../src/internal/resource-client.ts","../src/resources/storage/queues-group.ts","../src/resources/storage/sorted-maps-group.ts","../src/resources/storage/client.ts"],"mappings":"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"}
+{"version":3,"file":"storage.d.mts","names":[],"sources":["../src/domains/cloud-v2/memory-store-queues/types.ts","../src/domains/cloud-v2/memory-store-sorted-maps/types.ts","../src/internal/http/rate-limit-queue.ts","../src/internal/resource-client.ts","../src/resources/storage/queues-group.ts","../src/resources/storage/sorted-maps-group.ts","../src/resources/storage/client.ts"],"mappings":"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"}

package/dist/storage.mjs

@@ -1,5 +1,6 @@
-import { r as ApiError } from "./rate-limit-D1q2Js-z.mjs";
-import { a as IDEMPOTENT_METHOD_DEFAULTS, c as isDateTimeString, i as CREATE_METHOD_DEFAULTS, n as okRequest, r as parseEmptyResponse, s as isRecord, t as ResourceClient } from "./resource-client-D6Efj9fU.mjs";
+import { r as ApiError } from "./rate-limit-Co9i28qi.mjs";
+import { n as IDEMPOTENT_METHOD_DEFAULTS, t as CREATE_METHOD_DEFAULTS } from "./retry-CbHBw60o.mjs";
+import { a as isDateTimeString, i as isRecord, n as okRequest, r as parseEmptyResponse, t as ResourceClient } from "./resource-client-C_D--PYX.mjs";
 //#region src/domains/cloud-v2/memory-store-queues/builders.ts
 /**
 * Builds a `POST` request for the Open Cloud
@@ -138,7 +139,7 @@ const MALFORMED_DEQUEUE_MESSAGE = "Malformed memory-store dequeue response";
 */
 function parseQueueItemResponse(response) {
 	const item = wireBodyToQueueItem(response.body);
-	if (item === void 0) return malformedQueueItem(response.status);
+	if (item === void 0) return malformedQueueItem(response.status, response.body);
 	return {
 		data: item,
 		success: true
@@ -157,11 +158,12 @@ function parseQueueItemResponse(response) {
 */
 function parseDequeueResponse(response) {
 	const { body, status: statusCode } = response;
-	if (!isRecord(body)) return malformedDequeue(statusCode);
+	if (!isRecord(body)) return malformedDequeue(statusCode, body);
 	const { id, queueItems } = body;
-	if (typeof id !== "string" || !Array.isArray(queueItems)) return malformedDequeue(statusCode);
-	const items = queueItems.map(wireBodyToQueueItem);
-	if (!items.every(isQueueItem)) return malformedDequeue(statusCode);
+	if (typeof id !== "string") return malformedDequeue(statusCode, body);
+	if (queueItems !== void 0 && queueItems !== null && !Array.isArray(queueItems)) return malformedDequeue(statusCode, body);
+	const items = (queueItems ?? []).map(wireBodyToQueueItem);
+	if (!items.every(isQueueItem)) return malformedDequeue(statusCode, body);
 	return {
 		data: {
 			items,
@@ -191,18 +193,24 @@ function wireBodyToQueueItem(body) {
 		universeId
 	};
 }
-function malformedQueueItem(statusCode) {
+function malformedQueueItem(statusCode, body) {
 	return {
-		err: new ApiError(MALFORMED_QUEUE_ITEM_MESSAGE, { statusCode }),
+		err: new ApiError(MALFORMED_QUEUE_ITEM_MESSAGE, {
+			details: body,
+			statusCode
+		}),
 		success: false
 	};
 }
 function isQueueItem(item) {
 	return item !== void 0;
 }
-function malformedDequeue(statusCode) {
+function malformedDequeue(statusCode, body) {
 	return {
-		err: new ApiError(MALFORMED_DEQUEUE_MESSAGE, { statusCode }),
+		err: new ApiError(MALFORMED_DEQUEUE_MESSAGE, {
+			details: body,
+			statusCode
+		}),
 		success: false
 	};
 }
@@ -538,7 +546,7 @@ const UPDATE_OPERATION_LIMIT = Object.freeze({
 const UPDATE_REQUIRED_SCOPES = Object.freeze([WRITE_SCOPE]);
 //#endregion
 //#region src/domains/cloud-v2/memory-store-sorted-maps/parsers.ts
-const PATH_PATTERN = /^cloud\/v2\/universes\/(\d+)\/memory-store\/sorted-maps\/([^/]+)\/items\/([^/]+)$/;
+const PATH_PATTERN = /^cloud\/v2\/universes\/(\d+)\/memory-stores?\/sorted-maps\/([^/]+)\/items\/([^/]+)$/;
 const MALFORMED_MESSAGE = "Malformed memory-store sorted-map item response";
 const MALFORMED_LIST_MESSAGE = "Malformed memory-store sorted-map list response";
 /**
@@ -552,7 +560,7 @@ const MALFORMED_LIST_MESSAGE = "Malformed memory-store sorted-map list response"
 */
 function parseSortedMapItemResponse(response) {
 	const item = wireBodyToSortedMapItem(response.body);
-	if (item === void 0) return malformedSortedMapItem(response.status);
+	if (item === void 0) return malformedSortedMapItem(response.status, response.body);
 	return {
 		data: item,
 		success: true
@@ -561,10 +569,9 @@ function parseSortedMapItemResponse(response) {
 /**
 * Parses a successful `Cloud_ListMemoryStoreSortedMapItems` response
 * body into the public {@link ListSortedMapItemsResult} shape. Each
-* item in the `memoryStoreSortedMapItems` array is validated through
-* the same path-and-shape checks as
-* {@link parseSortedMapItemResponse}; a malformed entry rejects the
-* whole response.
+* item in the `items` array is validated through the same
+* path-and-shape checks as {@link parseSortedMapItemResponse}; a
+* malformed entry rejects the whole response.
 *
 * @param response - The full {@link HttpResponse} from the Open Cloud API.
 * @returns A success result wrapping the parsed
@@ -573,16 +580,17 @@ function parseSortedMapItemResponse(response) {
 */
 function parseListResponse(response) {
 	const { body, status: statusCode } = response;
-	if (!isRecord(body)) return malformedList(statusCode);
-	const { memoryStoreSortedMapItems, nextPageToken } = body;
-	if (!Array.isArray(memoryStoreSortedMapItems)) return malformedList(statusCode);
-	if (nextPageToken !== void 0 && typeof nextPageToken !== "string") return malformedList(statusCode);
-	const items = memoryStoreSortedMapItems.map(wireBodyToSortedMapItem);
-	if (!items.every(isSortedMapItem)) return malformedList(statusCode);
+	if (!isRecord(body)) return malformedList(statusCode, body);
+	const { items: rawItemsField, nextPageToken } = body;
+	if (rawItemsField !== void 0 && rawItemsField !== null && !Array.isArray(rawItemsField)) return malformedList(statusCode, body);
+	const normalizedToken = nextPageToken ?? void 0;
+	if (normalizedToken !== void 0 && typeof normalizedToken !== "string") return malformedList(statusCode, body);
+	const items = (rawItemsField ?? []).map(wireBodyToSortedMapItem);
+	if (!items.every(isSortedMapItem)) return malformedList(statusCode, body);
 	return {
 		data: {
 			items,
-			nextPageToken
+			nextPageToken: normalizedToken
 		},
 		success: true
 	};
@@ -610,12 +618,11 @@ function wireBodyToSortedMapItem(body) {
 	const match = PATH_PATTERN.exec(body.path);
 	const universeId = match?.[1];
 	const mapId = match?.[2];
-	const id = match?.[3];
-	if (universeId === void 0 || mapId === void 0 || id === void 0) return;
+	if (universeId === void 0 || mapId === void 0) return;
 	const sortKey = extractSortKey(body);
 	if (sortKey === "conflict") return;
 	return {
-		id,
+		id: body.id,
 		etag: body.etag,
 		expiresAt: new Date(body.expireTime),
 		mapId,
@@ -624,18 +631,24 @@ function wireBodyToSortedMapItem(body) {
 		value: body.value
 	};
 }
-function malformedSortedMapItem(statusCode) {
+function malformedSortedMapItem(statusCode, body) {
 	return {
-		err: new ApiError(MALFORMED_MESSAGE, { statusCode }),
+		err: new ApiError(MALFORMED_MESSAGE, {
+			details: body,
+			statusCode
+		}),
 		success: false
 	};
 }
 function isSortedMapItem(item) {
 	return item !== void 0;
 }
-function malformedList(statusCode) {
+function malformedList(statusCode, body) {
 	return {
-		err: new ApiError(MALFORMED_LIST_MESSAGE, { statusCode }),
+		err: new ApiError(MALFORMED_LIST_MESSAGE, {
+			details: body,
+			statusCode
+		}),
 		success: false
 	};
 }
@@ -824,6 +837,8 @@ var MemoryStoreSortedMapsGroup = class {
 * Every method returns a `Result` so callers handle failure
 * explicitly; no thrown error ever escapes the client.
 *
+* @since 0.1.0
+*
 * @example
 *
 * ```ts