@farukada/aws-langgraph-dynamodb-ts 1.0.0-rc.2 → 1.0.0

package/dist/esm/shared/errors/boundary.js

@@ -0,0 +1,54 @@
+import { redactedMessage } from '../logging/secret-patterns.js';
+import { truncateForLog } from '../logging/truncate.js';
+import { DynamoDBLangGraphError, isDynamoDBLangGraphError, toError, } from './base-error.js';
+import { awsDiagnostics, classifiableCause, classifyAwsError } from './classify.js';
+function stampContext(error, operation, tableName) {
+    const context = error.context;
+    if (typeof context !== 'object' || context === null)
+        return;
+    try {
+        context.operation ??= operation;
+        if (tableName !== undefined)
+            context.tableName ??= tableName;
+    }
+    catch {
+    }
+}
+export function toPublicError(error, operation, tableName) {
+    const normalized = toError(error);
+    const publicError = isDynamoDBLangGraphError(normalized)
+        ? normalized
+        : wrapForeignError(normalized, operation);
+    stampContext(publicError, operation, tableName);
+    return publicError;
+}
+export async function guardPublic(operation, fn, tableName) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+export async function* guardPublicIterable(operation, source, tableName) {
+    try {
+        for await (const item of source)
+            yield item;
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+export function guardPublicSync(operation, fn, tableName) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+export function wrapForeignError(cause, operation) {
+    const below = toError(cause);
+    const classifiable = classifiableCause(below);
+    return new DynamoDBLangGraphError(`${operation}: ${truncateForLog(below.name)}: ${redactedMessage(below)}`, classifyAwsError(classifiable), { operation, ...awsDiagnostics(classifiable) }, below);
+}

package/dist/esm/shared/errors/classify.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Hides which AWS failures are the same failure.
+ *
+ * An SDK error arrives as a name, an HTTP status, a Node network `code` or —
+ * for a cancelled transaction — a list of per-item reasons, and several of
+ * those arrivals mean one thing to a caller deciding what to do. Their mapping
+ * to one `ErrorCode`, and the retry layer's default list of transient names,
+ * come from one table here (record 19), so no call site compares an AWS
+ * exception name of its own.
+ */
+import type { ErrorContext } from './base-error.js';
+import { ErrorCode } from './error-code.js';
+/** The fields an AWS SDK v3 error, or a transport error under it, can carry. */
+/** The fields of an SDK error this module reads; exported for the retry layer's own walk. */
+export interface AwsErrorFields {
+    name?: string;
+    code?: string;
+    message?: string;
+    $metadata?: {
+        httpStatusCode?: number;
+        requestId?: string;
+        clockSkewCorrected?: boolean;
+    } | null;
+}
+/**
+ * The Node.js system error codes the SDK's own retry strategy treats as
+ * transient regardless of name (`@smithy/core` retry `NODEJS_TIMEOUT_ERROR_CODES`
+ * and `NODEJS_NETWORK_ERROR_CODES`). Matched on the error's own `code`.
+ */
+export declare const TRANSIENT_NETWORK_ERROR_CODES: readonly string[];
+/**
+ * HTTP statuses the SDK retries regardless of name: throttling (429) and the
+ * transient server statuses (`@smithy/core` retry `TRANSIENT_ERROR_STATUS_CODES`).
+ * They classify an error the SDK could not map to a modeled exception, which
+ * arrives as `name: 'Unknown'` with only its status.
+ */
+export declare const TRANSIENT_HTTP_STATUSES: readonly number[];
+/**
+ * AWS error name to code. Each name is declared by the installed
+ * `@aws-sdk/client-dynamodb` or `@aws-sdk/client-s3`, or documented on a page
+ * `test/static/aws-error-names.test.ts` cites; that test fails on any other.
+ */
+export declare const AWS_ERROR_CODES: Readonly<Record<string, ErrorCode>>;
+/**
+ * The retry layer's default tokens: every name {@link AWS_ERROR_CODES} maps to
+ * a retryable code, and the network codes. Derived rather than listed, so the
+ * retry layer and the code a caller sees share one list of transient names.
+ * They differ at two edges: the retry layer also retries on the SDK's
+ * `$retryable` trait, which {@link classifyAwsError} does not read, and it
+ * walks the cause chain matching `errno` and `syscall` too, where the
+ * classifier reads one error's `name`, `code` and status.
+ */
+export declare const DEFAULT_RETRYABLE_ERRORS: readonly string[];
+/**
+ * Whether the SDK itself would retry this signing failure.
+ *
+ * Accepts: `fields` — an error's own fields, as the SDK sets them.
+ *
+ * Returns: true when the SDK corrected its clock offset on the response
+ * (`$metadata.clockSkewCorrected`, set once the skew passes four minutes), or
+ * the service reports the signature expired (`InvalidSignatureException`
+ * saying so) — the SDK's own `isTransientError`, kept here because this
+ * package switches the SDK's retries off and would otherwise fail a host
+ * whose clock drifts on its first request, where a stock client recovers on
+ * the next.
+ *
+ * Throws: nothing.
+ */
+export declare function isCorrectedClockSkew(fields: AwsErrorFields): boolean;
+/**
+ * The code a failure that is not one of this library's own belongs to.
+ *
+ * Accepts: anything a `catch` can bind — an SDK error, a transport error, a
+ * value from caller-supplied code, `null`, a string.
+ *
+ * Returns: a transaction cancellation's code from its reasons (a sole
+ * `ConditionalCheckFailed` cause is `CONDITION_CONFLICT`; all-transient causes
+ * are `THROTTLED` or `CONTENTION`); otherwise `SERVICE_UNAVAILABLE` for a
+ * signing failure the SDK corrected its clock for or reports expired
+ * ({@link isCorrectedClockSkew}); otherwise the table's code for the error's
+ * own `name`; otherwise `SERVICE_UNAVAILABLE` for a transient network `code`;
+ * otherwise by HTTP status — 412 `CONDITION_CONFLICT`, 429 `THROTTLED`,
+ * 500/502/503/504 `SERVICE_UNAVAILABLE`; otherwise `AWS_REQUEST_FAILED` for an
+ * AWS-shaped error and `UNEXPECTED_ERROR` for anything else. Only the error's
+ * own fields are read, never its `cause`.
+ *
+ * Throws: nothing, for any value. It runs inside `catch` blocks.
+ */
+export declare function classifyAwsError(error: Error): ErrorCode;
+/**
+ * How far a walk down a cause chain goes before giving up: deep enough for
+ * any chain a real failure builds, and a bound in case a `cause` loops
+ * through objects a `Set` of seen nodes cannot pair. Shared by
+ * {@link classifiableCause} and the retry layer's own walk.
+ */
+export declare const MAX_CAUSE_DEPTH = 32;
+/**
+ * The node in `error`'s own cause chain — `error` itself, then its `cause`,
+ * then that error's own `cause`, and so on — that {@link classifyAwsError}
+ * does not answer `UNEXPECTED_ERROR` for.
+ *
+ * Accepts: `error` — the outermost failure to classify, already normalised by
+ * `toError`.
+ *
+ * Returns: the first node the classifier places under an AWS or network code,
+ * so a caller's own error wrapping a modeled SDK exception, an SDK error whose
+ * own `cause` is a raw transport failure, or a `RETRY_EXHAUSTED` error wrapping
+ * either as its own `cause`, still classifies — and still yields diagnostics —
+ * on the AWS/network failure underneath rather than losing it one level up —
+ * the same failure the retry layer's cause-chain walk (`isRetryableError` in
+ * `shared/dynamodb/retry.ts`) already sees. `error` itself when nothing in its
+ * chain classifies either. The walk gives up after {@link MAX_CAUSE_DEPTH}
+ * nodes, and a cycle in the chain stops it rather than looping, exactly as
+ * that other walk does.
+ *
+ * Throws: nothing, for any value `toError` can produce.
+ */
+export declare function classifiableCause(error: Error): Error;
+/**
+ * The fields an operator needs first, lifted off an AWS-shaped error.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: `awsErrorName`, `requestId` and `httpStatusCode`, each only when
+ * present and well-typed, for an error carrying `$metadata` or a name the table
+ * knows or that ends in `Exception`; `{}` for anything else — a bare network
+ * failure included, since it may be a caller's own connection rather than AWS's.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function awsDiagnostics(error: Error): Pick<ErrorContext, 'awsErrorName' | 'requestId' | 'httpStatusCode'>;
+/**
+ * Whether a failed request ended on this side, before the service answered it.
+ *
+ * Accepts: anything a `catch` can bind, and `undefined`.
+ *
+ * Returns: true when the failure, or a cause beneath it, is a cut this side
+ * made — the SDK's own `TimeoutError` or `AbortError`, or a Node network error
+ * such as `ECONNRESET` or `ETIMEDOUT` — and no node on the way carries the HTTP
+ * status of a response. The service may still apply a request cut that way
+ * after the caller has stopped waiting for it. False for everything else: a
+ * failure the service answered, and one that says nothing about the transport,
+ * such as a value a caller's own code threw. A cycle in the chain ends the walk.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function endedWithoutAnswer(error: Error | undefined): boolean;
+/**
+ * Whether one attempt's own failure leaves DynamoDB free to apply it later,
+ * judged from that attempt alone.
+ *
+ * Accepts: anything a `catch` can bind, and `undefined`.
+ *
+ * Returns: true when the attempt {@link endedWithoutAnswer}; when the service
+ * answered that its own earlier attempt under the same `ClientRequestToken`
+ * was still being processed (`TransactionInProgressException`); or when it
+ * answered with a server error, an HTTP 5xx. AWS says of a 500
+ * (`InternalServerError`) that the request "may have succeeded or failed", with
+ * no later point documented as settling it (DynamoDB Developer Guide, *Error
+ * handling*:
+ * https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html);
+ * this library treats every 5xx the same way. False for a refusal, a throttle,
+ * or any other definite answer.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function mayStillBeInFlight(error: Error | undefined): boolean;
+/**
+ * Whether the service refused a request outright, so that none of it was applied.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for a cancelled transaction — DynamoDB applies none of a
+ * transaction it cancels — and for a failure the classifier places under a
+ * refusal: a malformed request, a denied permission, a missing table or index,
+ * a failed condition. False for everything else, a spent retry budget and a
+ * cancel included, since neither says what the service did.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function refusedByService(error: Error): boolean;
+/**
+ * Whether an S3 read failed because the object is gone.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for `NoSuchKey` only. `NOT_FOUND` also covers a missing
+ * bucket, which is a configuration fault; reading it as a lost payload would
+ * write off data that is still there.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function isMissingObject(error: Error): boolean;
+/**
+ * Whether reading a bucket's lifecycle configuration failed because the bucket
+ * has none.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for `NoSuchLifecycleConfiguration` only. `NOT_FOUND` also
+ * covers a missing bucket, table or object; reading one of those as "no rules
+ * yet" would start a rule set for a bucket that is not there.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function isMissingLifecycleConfiguration(error: Error): boolean;

package/dist/esm/shared/errors/classify.js

@@ -0,0 +1,220 @@
+import { conditionalCheckFailure, throttledCancellation, transientCancellation, } from '../dynamodb/cancellation.js';
+import { ErrorCode } from './error-code.js';
+export const TRANSIENT_NETWORK_ERROR_CODES = [
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'EPIPE',
+    'ETIMEDOUT',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+];
+export const TRANSIENT_HTTP_STATUSES = [429, 500, 502, 503, 504];
+const PRECONDITION_FAILED_STATUS = 412;
+const TRANSACTION_CANCELLED = 'TransactionCanceledException';
+export const AWS_ERROR_CODES = {
+    ProvisionedThroughputExceededException: ErrorCode.THROTTLED,
+    ThrottlingException: ErrorCode.THROTTLED,
+    RequestLimitExceeded: ErrorCode.THROTTLED,
+    SlowDown: ErrorCode.THROTTLED,
+    InternalServerError: ErrorCode.SERVICE_UNAVAILABLE,
+    InternalFailure: ErrorCode.SERVICE_UNAVAILABLE,
+    ServiceUnavailable: ErrorCode.SERVICE_UNAVAILABLE,
+    InternalError: ErrorCode.SERVICE_UNAVAILABLE,
+    RequestTimeout: ErrorCode.SERVICE_UNAVAILABLE,
+    RequestTimeoutException: ErrorCode.SERVICE_UNAVAILABLE,
+    TimeoutError: ErrorCode.SERVICE_UNAVAILABLE,
+    TransactionConflictException: ErrorCode.CONTENTION,
+    TransactionInProgressException: ErrorCode.CONTENTION,
+    ReplicatedWriteConflictException: ErrorCode.CONTENTION,
+    ConditionalRequestConflict: ErrorCode.CONTENTION,
+    AccessDeniedException: ErrorCode.ACCESS_DENIED,
+    AccessDenied: ErrorCode.ACCESS_DENIED,
+    ExpiredTokenException: ErrorCode.ACCESS_DENIED,
+    ExpiredToken: ErrorCode.ACCESS_DENIED,
+    IncompleteSignature: ErrorCode.ACCESS_DENIED,
+    IncompleteSignatureException: ErrorCode.ACCESS_DENIED,
+    InvalidAccessKeyId: ErrorCode.ACCESS_DENIED,
+    InvalidSignatureException: ErrorCode.ACCESS_DENIED,
+    MissingAuthenticationTokenException: ErrorCode.ACCESS_DENIED,
+    NotAuthorized: ErrorCode.ACCESS_DENIED,
+    RequestTimeTooSkewed: ErrorCode.ACCESS_DENIED,
+    SignatureDoesNotMatch: ErrorCode.ACCESS_DENIED,
+    UnrecognizedClientException: ErrorCode.ACCESS_DENIED,
+    CredentialsProviderError: ErrorCode.ACCESS_DENIED,
+    ResourceNotFoundException: ErrorCode.NOT_FOUND,
+    NoSuchBucket: ErrorCode.NOT_FOUND,
+    NoSuchKey: ErrorCode.NOT_FOUND,
+    NoSuchLifecycleConfiguration: ErrorCode.NOT_FOUND,
+    ValidationException: ErrorCode.AWS_REJECTED,
+    ValidationError: ErrorCode.AWS_REJECTED,
+    IdempotentParameterMismatchException: ErrorCode.AWS_REJECTED,
+    MalformedHttpRequestException: ErrorCode.AWS_REJECTED,
+    RequestEntityTooLargeException: ErrorCode.AWS_REJECTED,
+    ConditionalCheckFailedException: ErrorCode.CONDITION_CONFLICT,
+    PreconditionFailed: ErrorCode.CONDITION_CONFLICT,
+    ItemCollectionSizeLimitExceededException: ErrorCode.AWS_REQUEST_FAILED,
+    InvalidEndpointException: ErrorCode.AWS_REQUEST_FAILED,
+    TransactionCanceledException: ErrorCode.AWS_REQUEST_FAILED,
+    AbortError: ErrorCode.ABORTED,
+};
+const RETRYABLE_CODES = [
+    ErrorCode.THROTTLED,
+    ErrorCode.SERVICE_UNAVAILABLE,
+    ErrorCode.CONTENTION,
+];
+export const DEFAULT_RETRYABLE_ERRORS = [
+    ...Object.entries(AWS_ERROR_CODES)
+        .filter(([, code]) => RETRYABLE_CODES.includes(code))
+        .map(([name]) => name),
+    ...TRANSIENT_NETWORK_ERROR_CODES,
+];
+function declaredCodeOf(name) {
+    return typeof name === 'string' && Object.hasOwn(AWS_ERROR_CODES, name)
+        ? AWS_ERROR_CODES[name]
+        : undefined;
+}
+export function isCorrectedClockSkew(fields) {
+    if (fields.$metadata?.clockSkewCorrected === true)
+        return true;
+    return (fields.name === 'InvalidSignatureException' &&
+        typeof fields.message === 'string' &&
+        fields.message.includes('Signature expired'));
+}
+function statusOf(fields) {
+    const metadata = fields.$metadata;
+    return typeof metadata === 'object' &&
+        metadata !== null &&
+        typeof metadata.httpStatusCode === 'number'
+        ? metadata.httpStatusCode
+        : undefined;
+}
+function isAwsShaped(fields) {
+    if (typeof fields.$metadata === 'object' && fields.$metadata !== null)
+        return true;
+    const { name } = fields;
+    return (typeof name === 'string' && (declaredCodeOf(name) !== undefined || name.endsWith('Exception')));
+}
+function cancellationCode(error) {
+    if (conditionalCheckFailure(error) !== undefined)
+        return ErrorCode.CONDITION_CONFLICT;
+    if (transientCancellation(error) === true) {
+        return throttledCancellation(error) ? ErrorCode.THROTTLED : ErrorCode.CONTENTION;
+    }
+    return AWS_ERROR_CODES[TRANSACTION_CANCELLED];
+}
+export function classifyAwsError(error) {
+    if (typeof error !== 'object' || error === null)
+        return ErrorCode.UNEXPECTED_ERROR;
+    const fields = error;
+    if (fields.name === TRANSACTION_CANCELLED)
+        return cancellationCode(error);
+    if (isCorrectedClockSkew(fields))
+        return ErrorCode.SERVICE_UNAVAILABLE;
+    const declared = declaredCodeOf(fields.name);
+    if (declared !== undefined)
+        return declared;
+    if (typeof fields.code === 'string' && TRANSIENT_NETWORK_ERROR_CODES.includes(fields.code)) {
+        return ErrorCode.SERVICE_UNAVAILABLE;
+    }
+    const status = statusOf(fields);
+    if (status === PRECONDITION_FAILED_STATUS)
+        return ErrorCode.CONDITION_CONFLICT;
+    if (status === 429)
+        return ErrorCode.THROTTLED;
+    if (status !== undefined && TRANSIENT_HTTP_STATUSES.includes(status)) {
+        return ErrorCode.SERVICE_UNAVAILABLE;
+    }
+    return isAwsShaped(fields) ? ErrorCode.AWS_REQUEST_FAILED : ErrorCode.UNEXPECTED_ERROR;
+}
+export const MAX_CAUSE_DEPTH = 32;
+export function classifiableCause(error) {
+    const seen = new WeakSet();
+    let node = error;
+    for (let depth = 0; depth <= MAX_CAUSE_DEPTH; depth += 1) {
+        if (classifyAwsError(node) !== ErrorCode.UNEXPECTED_ERROR)
+            return node;
+        if (typeof node !== 'object' || node === null || seen.has(node))
+            break;
+        seen.add(node);
+        const next = node.cause;
+        if (next === undefined)
+            break;
+        node = next;
+    }
+    return error;
+}
+export function awsDiagnostics(error) {
+    if (typeof error !== 'object' || error === null)
+        return {};
+    const fields = error;
+    if (!isAwsShaped(fields))
+        return {};
+    const out = {};
+    if (typeof fields.name === 'string')
+        out.awsErrorName = fields.name;
+    const status = statusOf(fields);
+    if (status !== undefined)
+        out.httpStatusCode = status;
+    const requestId = fields.$metadata?.requestId;
+    if (typeof requestId === 'string')
+        out.requestId = requestId;
+    return out;
+}
+const CLIENT_SIDE_CUTS = ['TimeoutError', 'AbortError'];
+const MAX_ANSWER_DEPTH = 8;
+export function endedWithoutAnswer(error) {
+    const seen = new WeakSet();
+    let node = error;
+    for (let depth = 0; depth < MAX_ANSWER_DEPTH; depth += 1) {
+        if (typeof node !== 'object' || node === null || seen.has(node))
+            return false;
+        seen.add(node);
+        const fields = node;
+        if (statusOf(fields) !== undefined)
+            return false;
+        if (typeof fields.name === 'string' && CLIENT_SIDE_CUTS.includes(fields.name))
+            return true;
+        if (typeof fields.code === 'string' && TRANSIENT_NETWORK_ERROR_CODES.includes(fields.code)) {
+            return true;
+        }
+        node = node.cause;
+    }
+    return false;
+}
+const TRANSACTION_IN_PROGRESS = 'TransactionInProgressException';
+const SERVER_ERROR_STATUS_MIN = 500;
+const SERVER_ERROR_STATUS_MAX = 599;
+export function mayStillBeInFlight(error) {
+    if (endedWithoutAnswer(error))
+        return true;
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const fields = error;
+    if (fields.name === TRANSACTION_IN_PROGRESS)
+        return true;
+    const status = statusOf(fields);
+    return (status !== undefined && status >= SERVER_ERROR_STATUS_MIN && status <= SERVER_ERROR_STATUS_MAX);
+}
+const REFUSED = [
+    ErrorCode.AWS_REJECTED,
+    ErrorCode.ACCESS_DENIED,
+    ErrorCode.NOT_FOUND,
+    ErrorCode.CONDITION_CONFLICT,
+];
+export function refusedByService(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    if (error.name === TRANSACTION_CANCELLED)
+        return true;
+    return REFUSED.includes(classifyAwsError(error));
+}
+export function isMissingObject(error) {
+    return (typeof error === 'object' && error !== null && error.name === 'NoSuchKey');
+}
+export function isMissingLifecycleConfiguration(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        error.name === 'NoSuchLifecycleConfiguration');
+}

package/dist/{shared/errors/error-code.js → esm/shared/errors/error-code.d.ts}

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Hides which outcomes a caller can tell apart.
  *
@@ -8,33 +7,32 @@
  * onto an existing code without touching this list, and the list is frozen so
  * no consumer sharing it in a process can change what a comparison means.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorCode = void 0;
 /** Stable, branchable classification for every error this library throws. */
-var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode["VALIDATION"] = "VALIDATION";
+export declare enum ErrorCode {
+    VALIDATION = "VALIDATION",
     /** A row or payload written in a format version newer than this package reads. */
-    ErrorCode["FORMAT_UNSUPPORTED"] = "FORMAT_UNSUPPORTED";
+    FORMAT_UNSUPPORTED = "FORMAT_UNSUPPORTED",
     /**
-     * A checkpoint a delta channel still needs has expired, so the channel cannot
-     * be reconstructed and the read refuses rather than returning a shorter value.
+     * A checkpoint a delta channel still needs cannot be read — it has expired,
+     * the sweep has since removed it, or the chain of parents loops back on
+     * itself — so the channel cannot be reconstructed and the read refuses
+     * rather than returning a shorter value.
      */
-    ErrorCode["ANCESTOR_EXPIRED"] = "ANCESTOR_EXPIRED";
-    ErrorCode["CONDITION_CONFLICT"] = "CONDITION_CONFLICT";
-    ErrorCode["RETRY_EXHAUSTED"] = "RETRY_EXHAUSTED";
-    ErrorCode["BATCH_WRITE_INCOMPLETE"] = "BATCH_WRITE_INCOMPLETE";
-    ErrorCode["COMPRESSION_LIMIT"] = "COMPRESSION_LIMIT";
+    ANCESTOR_EXPIRED = "ANCESTOR_EXPIRED",
+    CONDITION_CONFLICT = "CONDITION_CONFLICT",
+    RETRY_EXHAUSTED = "RETRY_EXHAUSTED",
+    BATCH_WRITE_INCOMPLETE = "BATCH_WRITE_INCOMPLETE",
+    COMPRESSION_LIMIT = "COMPRESSION_LIMIT",
     /**
      * A stored payload's bytes do not match the form its row declares: the row
      * says gzip and they are not, or they are not the serializer's output. The
      * payload can never be read, so it is reported rather than retried.
      */
-    ErrorCode["PAYLOAD_CORRUPT"] = "PAYLOAD_CORRUPT";
-    ErrorCode["S3_OFFLOAD_FAILED"] = "S3_OFFLOAD_FAILED";
-    ErrorCode["RESULT_TRUNCATED"] = "RESULT_TRUNCATED";
-    ErrorCode["ABORTED"] = "ABORTED";
-    ErrorCode["COMPENSATION_FAILED"] = "COMPENSATION_FAILED";
+    PAYLOAD_CORRUPT = "PAYLOAD_CORRUPT",
+    S3_OFFLOAD_FAILED = "S3_OFFLOAD_FAILED",
+    RESULT_TRUNCATED = "RESULT_TRUNCATED",
+    ABORTED = "ABORTED",
+    COMPENSATION_FAILED = "COMPENSATION_FAILED",
     /**
      * AWS throttled the request: `ProvisionedThroughputExceededException`,
      * `ThrottlingException`, `RequestLimitExceeded`, S3's `SlowDown`, an HTTP
@@ -42,58 +40,56 @@ var ErrorCode;
      * a throttling reason. Back off, or raise the table's capacity or the account
      * quota.
      */
-    ErrorCode["THROTTLED"] = "THROTTLED";
+    THROTTLED = "THROTTLED",
     /**
      * AWS or the network failed transiently: `InternalServerError`,
      * `InternalFailure`, `ServiceUnavailable`, S3's `InternalError`, a request
      * timeout (`RequestTimeout`, `RequestTimeoutException`, the SDK's
-     * `TimeoutError`), an HTTP 500/502/503/504, or a reset, refused or
-     * unreachable connection. Retry after a backoff. A write that failed this way
+     * `TimeoutError`), an HTTP 500/502/503/504, a reset, refused or unreachable
+     * connection, or a signing failure the SDK corrected its clock for or
+     * reports as expired. Retry after a backoff. A write that failed this way
      * may still have been applied.
      */
-    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
     /**
      * Another request was writing the same item or object at the same moment:
      * `TransactionConflictException`, `TransactionInProgressException`,
      * `ReplicatedWriteConflictException`, S3's `ConditionalRequestConflict`, or a
      * cancelled transaction whose only transient cause is a conflict. Retry; more
-     * capacity would not help.
+     * capacity would not help. `ensureS3LifecycleRule()` raises it when every one
+     * of its five rounds needs a write.
      */
-    ErrorCode["CONTENTION"] = "CONTENTION";
+    CONTENTION = "CONTENTION",
     /**
      * AWS refused the caller's identity or permissions: `AccessDeniedException`,
      * S3's `AccessDenied`, an expired, unrecognised or malformed credential or
-     * signature. Fix the credentials or the IAM policy; do not retry.
-     * `context.awsErrorName` says which.
+     * signature — or the SDK's credential chain found no credentials to sign
+     * with (`CredentialsProviderError`). Fix the credentials or the IAM policy;
+     * do not retry. `context.awsErrorName` says which.
      */
-    ErrorCode["ACCESS_DENIED"] = "ACCESS_DENIED";
+    ACCESS_DENIED = "ACCESS_DENIED",
     /**
-     * The table, index, bucket or object is not there: `ResourceNotFoundException`,
-     * S3's `NoSuchBucket` or `NoSuchKey`. Not an absent item — a read of a key that
-     * holds nothing returns nothing.
+     * The table or the bucket is not there: `ResourceNotFoundException`, or S3's
+     * `NoSuchBucket` from the lifecycle calls. A missing index is `AWS_REJECTED`
+     * — DynamoDB refuses a query naming one with a `ValidationException` — and a
+     * missing S3 object on a transfer is `S3_OFFLOAD_FAILED`. Not an absent item:
+     * a read of a key that holds nothing returns nothing.
      */
-    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    NOT_FOUND = "NOT_FOUND",
     /**
      * AWS rejected the request as malformed: `ValidationException`,
      * AWS's `ValidationError` common error, `IdempotentParameterMismatchException`,
      * or a request body it could not read or accept. Retrying the same request
      * fails the same way.
      */
-    ErrorCode["AWS_REJECTED"] = "AWS_REJECTED";
+    AWS_REJECTED = "AWS_REJECTED",
     /** An AWS request failed and no narrower code applies; `context.awsErrorName` names it. */
-    ErrorCode["AWS_REQUEST_FAILED"] = "AWS_REQUEST_FAILED";
+    AWS_REQUEST_FAILED = "AWS_REQUEST_FAILED",
     /**
      * A failure that came neither from this package's own checks nor from AWS:
      * a `VectorBackend`, an `Embeddings` model, a `serde` or a `MultiSessionHistory`
      * threw something of its own, or this package has a bug. The original is
      * `cause`.
      */
-    ErrorCode["UNEXPECTED_ERROR"] = "UNEXPECTED_ERROR";
-})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
-// A TypeScript enum compiles to a plain, writable object, and this one is
-// exported from the package root: every consumer in a process shares the same
-// object. One dependency assigning to a member — a test stub, a patch, a
-// typo — rewrites what `error.code === ErrorCode.X` means for every other
-// consumer at once, and nothing is raised anywhere; the branch simply stops
-// matching. Freezing turns that into a refusal at the assignment.
-Object.freeze(ErrorCode);
+    UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
+}

package/dist/esm/shared/errors/error-code.js

@@ -0,0 +1,24 @@
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["VALIDATION"] = "VALIDATION";
+    ErrorCode["FORMAT_UNSUPPORTED"] = "FORMAT_UNSUPPORTED";
+    ErrorCode["ANCESTOR_EXPIRED"] = "ANCESTOR_EXPIRED";
+    ErrorCode["CONDITION_CONFLICT"] = "CONDITION_CONFLICT";
+    ErrorCode["RETRY_EXHAUSTED"] = "RETRY_EXHAUSTED";
+    ErrorCode["BATCH_WRITE_INCOMPLETE"] = "BATCH_WRITE_INCOMPLETE";
+    ErrorCode["COMPRESSION_LIMIT"] = "COMPRESSION_LIMIT";
+    ErrorCode["PAYLOAD_CORRUPT"] = "PAYLOAD_CORRUPT";
+    ErrorCode["S3_OFFLOAD_FAILED"] = "S3_OFFLOAD_FAILED";
+    ErrorCode["RESULT_TRUNCATED"] = "RESULT_TRUNCATED";
+    ErrorCode["ABORTED"] = "ABORTED";
+    ErrorCode["COMPENSATION_FAILED"] = "COMPENSATION_FAILED";
+    ErrorCode["THROTTLED"] = "THROTTLED";
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    ErrorCode["CONTENTION"] = "CONTENTION";
+    ErrorCode["ACCESS_DENIED"] = "ACCESS_DENIED";
+    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ErrorCode["AWS_REJECTED"] = "AWS_REJECTED";
+    ErrorCode["AWS_REQUEST_FAILED"] = "AWS_REQUEST_FAILED";
+    ErrorCode["UNEXPECTED_ERROR"] = "UNEXPECTED_ERROR";
+})(ErrorCode || (ErrorCode = {}));
+Object.freeze(ErrorCode);