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

package/dist/history/internal/validation.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSessionId = validateSessionId;
-exports.validateStorableMessages = validateStorableMessages;
-exports.validateMessageWindow = validateMessageWindow;
-const messages_1 = require("@langchain/core/messages");
-const constants_1 = require("../../shared/constants");
-const errors_1 = require("../../shared/errors/errors");
-const primitives_1 = require("../../shared/validation/primitives");
-const keys_1 = require("./keys");
-/**
- * Validate a session id is a non-blank, separator- and control-char-free string
- * of at most 1024 bytes. Applied on every entry point, not just the write path: a bad value
- * used to reach DynamoDB and surface as a raw AWS SDK exception on reads,
- * while the identical value threw this library's typed `ValidationError` on a
- * write.
- */
-function validateSessionId(sessionId) {
-    (0, primitives_1.validateIdentifier)(sessionId, keys_1.SORT_KEY_SEPARATOR, 'sessionId', constants_1.MAX_PARTITION_ID_BYTES);
-}
-/**
- * Reject a message this adapter could never read back. The check *is* the
- * read side's own rebuild (`mapStoredMessagesToChatMessages`), so write and
- * read agree by construction: a `RemoveMessage`, or a tool, function or
- * generic message missing its required field, fails here with a typed error
- * instead of being persisted and then skipped or thrown by `getMessages`.
- */
-function validateStorableMessages(stored) {
-    stored.forEach((message, index) => {
-        try {
-            (0, messages_1.mapStoredMessagesToChatMessages)([message]);
-        }
-        catch (error) {
-            throw new errors_1.ValidationError(`messages[${index}] of type "${message.type}" cannot be stored: ${error.message}`, 'messages');
-        }
-    });
-}
-/**
- * Validate a `getMessages` window: `limit`, when given, a positive integer;
- * `before`, when given, a valid `Date`. Checked before any DynamoDB call so a
- * bad value fails with a typed error rather than a raw `ValidationException`
- * (or, for an invalid Date, a NaN-derived sort key that matches nothing).
- */
-function validateMessageWindow(window) {
-    if (window.limit !== undefined && (!Number.isInteger(window.limit) || window.limit < 1)) {
-        throw new errors_1.ValidationError('limit must be a positive integer', 'limit');
-    }
-    if (window.before !== undefined) {
-        const time = typeof window.before.getTime === 'function' ? window.before.getTime() : Number.NaN;
-        if (!Number.isFinite(time))
-            throw new errors_1.ValidationError('before must be a valid Date', 'before');
-    }
-}

package/dist/shared/codec/descriptor-keys.d.ts

@@ -1,12 +0,0 @@
-import { PayloadLocation } from './codec';
-/**
- * The part of a descriptor cleanup needs: where the payload lives and, for S3,
- * its key. A full `PayloadDescriptor` satisfies it, and so does the projection
- * a pre-write read returns without the inline bytes.
- */
-export interface DescriptorRef {
-    location: PayloadLocation;
-    s3Key?: string;
-}
-/** Collect the S3 keys of any offloaded descriptors, for orphan cleanup. */
-export declare function collectS3Keys(descriptors: readonly DescriptorRef[]): string[];

package/dist/shared/codec/descriptor-keys.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectS3Keys = collectS3Keys;
-const codec_1 = require("./codec");
-/** Collect the S3 keys of any offloaded descriptors, for orphan cleanup. */
-function collectS3Keys(descriptors) {
-    const keys = [];
-    for (const descriptor of descriptors) {
-        if (descriptor.location === codec_1.PayloadLocation.S3 && descriptor.s3Key !== undefined) {
-            keys.push(descriptor.s3Key);
-        }
-    }
-    return keys;
-}

package/dist/shared/codec/encode.d.ts

@@ -1,13 +0,0 @@
-import { type CodecDeps, type PayloadDescriptor } from './codec';
-/** Options controlling where an offloaded payload's S3 key is built from. */
-export interface EncodeOptions {
-    keyParts: readonly string[];
-}
-/**
- * Encode `value`: serialize via serde, compress (if configured), then offload
- * to S3 when the compressed bytes exceed the offloader's threshold. Returns a
- * descriptor recording how to read it back. Without an offloader, bytes that
- * cannot fit a DynamoDB item are rejected here (see
- * {@link assertInlinePayloadFits}).
- */
-export declare function encodePayload<T>(value: T, deps: CodecDeps, options: EncodeOptions): Promise<PayloadDescriptor>;

package/dist/shared/codec/encode.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodePayload = encodePayload;
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const codec_1 = require("./codec");
-const compression_1 = require("./compression");
-/**
- * Reject bytes that cannot be stored inline. Without an offloader the only
- * alternative is a raw `ValidationException` from DynamoDB after the network
- * round trip, which names neither the cause nor the remedy.
- */
-function assertInlinePayloadFits(bytes, deps) {
-    if (bytes.length <= constants_1.MAX_INLINE_PAYLOAD_BYTES)
-        return;
-    const hint = deps.compression?.enabled
-        ? ''
-        : ', or enable compression if the data compresses well';
-    throw new errors_1.ValidationError(`payload of ${bytes.length} bytes exceeds the ${constants_1.MAX_INLINE_PAYLOAD_BYTES}-byte inline limit ` +
-        `(DynamoDB items are capped at 400 KB); configure s3 offloading${hint}`, 'payload');
-}
-/**
- * Encode `value`: serialize via serde, compress (if configured), then offload
- * to S3 when the compressed bytes exceed the offloader's threshold. Returns a
- * descriptor recording how to read it back. Without an offloader, bytes that
- * cannot fit a DynamoDB item are rejected here (see
- * {@link assertInlinePayloadFits}).
- */
-async function encodePayload(value, deps, options) {
-    const [serdeType, raw] = await deps.serde.dumpsTyped(value);
-    const { bytes, compressed } = deps.compression
-        ? await (0, compression_1.compress)(raw, deps.compression)
-        : { bytes: raw, compressed: false };
-    const base = { schemaVersion: codec_1.DESCRIPTOR_SCHEMA_VERSION, serdeType, compressed };
-    if (deps.offloader && deps.offloader.shouldOffload(bytes)) {
-        const s3Key = deps.offloader.buildKey(options.keyParts);
-        await deps.offloader.upload(s3Key, bytes);
-        return { ...base, location: codec_1.PayloadLocation.S3, s3Key };
-    }
-    if (!deps.offloader)
-        assertInlinePayloadFits(bytes, deps);
-    return { ...base, location: codec_1.PayloadLocation.INLINE, bytes };
-}

package/dist/shared/codec/payload-loss.d.ts

@@ -1,12 +0,0 @@
-/**
- * True when an offloaded object no longer exists — a lifecycle sweep removed
- * it, or a competing overwrite deleted it between a row read and the download.
- */
-export declare function isMissingObjectError(error: Error): boolean;
-/**
- * True when a payload can never be read again — its object is gone, it trips
- * the decompression guard, or its key lies outside the row's own path — as
- * opposed to a failure that may succeed on retry or after a configuration fix
- * (throttling, network, permissions).
- */
-export declare function isPermanentPayloadLoss(error: Error): boolean;

package/dist/shared/codec/payload-loss.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMissingObjectError = isMissingObjectError;
-exports.isPermanentPayloadLoss = isPermanentPayloadLoss;
-const error_code_1 = require("../errors/error-code");
-/**
- * True when an offloaded object no longer exists — a lifecycle sweep removed
- * it, or a competing overwrite deleted it between a row read and the download.
- */
-function isMissingObjectError(error) {
-    const coded = error;
-    return coded.code === error_code_1.ErrorCode.S3_OFFLOAD_FAILED && coded.cause?.name === 'NoSuchKey';
-}
-/** Validation fields that condemn the row itself rather than the caller's input. */
-const ROW_REJECTION_FIELDS = ['s3Key', 'descriptor'];
-/**
- * True when a row's descriptor can never be read by this adapter: its key lies
- * outside the S3 path its own identifiers allow (see `assertKeyInScope`), or
- * its shape is one this version does not understand.
- */
-function isRowRejection(error) {
-    const coded = error;
-    return (coded.code === error_code_1.ErrorCode.VALIDATION &&
-        coded.context?.field !== undefined &&
-        ROW_REJECTION_FIELDS.includes(coded.context.field));
-}
-/**
- * True when a payload can never be read again — its object is gone, it trips
- * the decompression guard, or its key lies outside the row's own path — as
- * opposed to a failure that may succeed on retry or after a configuration fix
- * (throttling, network, permissions).
- */
-function isPermanentPayloadLoss(error) {
-    const coded = error;
-    return (coded.code === error_code_1.ErrorCode.COMPRESSION_LIMIT ||
-        isMissingObjectError(error) ||
-        isRowRejection(error));
-}

package/dist/shared/codec/s3/adapter-config.d.ts

@@ -1,13 +0,0 @@
-import type { DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
-import { type S3OffloadConfig } from './config';
-/** The adapters that share one bucket, each under its own default key prefix. */
-export type AdapterName = 'checkpointer' | 'store' | 'history';
-/**
- * Resolve an adapter's `s3` option into the offloader's configuration: the
- * adapter-scoped default key prefix when none is given, and the DynamoDB
- * client's region when the S3 client config names none. The S3 SDK does not
- * follow region redirects by default, so a bucket reachable only through the
- * region the DynamoDB side was configured with used to fail with an opaque
- * `PermanentRedirect` on the first offload.
- */
-export declare function offloaderConfigFor(s3: S3OffloadConfig, adapter: AdapterName, clientConfig?: DynamoDBClientConfig): S3OffloadConfig;

package/dist/shared/codec/s3/adapter-config.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.offloaderConfigFor = offloaderConfigFor;
-const constants_1 = require("../../constants");
-const client_types_1 = require("./client-types");
-const config_1 = require("./config");
-/**
- * Resolve an adapter's `s3` option into the offloader's configuration: the
- * adapter-scoped default key prefix when none is given, and the DynamoDB
- * client's region when the S3 client config names none. The S3 SDK does not
- * follow region redirects by default, so a bucket reachable only through the
- * region the DynamoDB side was configured with used to fail with an opaque
- * `PermanentRedirect` on the first offload.
- */
-function offloaderConfigFor(s3, adapter, clientConfig) {
-    const region = (0, client_types_1.s3ClientOptions)(s3.clientConfig).region ?? clientConfig?.region;
-    return {
-        ...s3,
-        keyPrefix: s3.keyPrefix ?? (0, config_1.defaultAdapterKeyPrefix)(constants_1.DEFAULT_S3_KEY_PREFIX, adapter),
-        ...(region === undefined ? {} : { clientConfig: { ...s3.clientConfig, region } }),
-    };
-}

package/dist/shared/codec/s3/bounded-body.d.ts

@@ -1,14 +0,0 @@
-import { DynamoDBLangGraphError } from '../../errors/base-error';
-/** The part of an S3 `GetObject` body this module relies on. */
-export interface S3Body {
-    transformToByteArray(): Promise<Uint8Array>;
-}
-/** The typed error for an object over the download cap. */
-export declare function oversizedObjectError(key: string, bytes: number, maxBytes: number): DynamoDBLangGraphError;
-/**
- * Buffer an S3 body without ever holding more than `maxBytes` of it. A
- * streaming body is consumed chunk by chunk and abandoned the moment the
- * running total passes the cap; a body that only offers
- * `transformToByteArray()` is read whole and then checked.
- */
-export declare function readBodyBounded(body: S3Body, key: string, maxBytes: number): Promise<Uint8Array>;

package/dist/shared/codec/s3/bounded-body.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.oversizedObjectError = oversizedObjectError;
-exports.readBodyBounded = readBodyBounded;
-const base_error_1 = require("../../errors/base-error");
-const error_code_1 = require("../../errors/error-code");
-/** The typed error for an object over the download cap. */
-function oversizedObjectError(key, bytes, maxBytes) {
-    return new base_error_1.DynamoDBLangGraphError(`S3 object ${key} exceeds the ${maxBytes}-byte maxDownloadBytes cap ` +
-        `(${bytes} bytes declared or read)`, error_code_1.ErrorCode.S3_OFFLOAD_FAILED, { operation: 'download', key });
-}
-function concat(chunks, total) {
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}
-/**
- * Buffer an S3 body without ever holding more than `maxBytes` of it. A
- * streaming body is consumed chunk by chunk and abandoned the moment the
- * running total passes the cap; a body that only offers
- * `transformToByteArray()` is read whole and then checked.
- */
-async function readBodyBounded(body, key, maxBytes) {
-    const streaming = body;
-    const iterate = streaming[Symbol.asyncIterator];
-    if (typeof iterate !== 'function') {
-        const whole = new Uint8Array(await body.transformToByteArray());
-        if (whole.length > maxBytes)
-            throw oversizedObjectError(key, whole.length, maxBytes);
-        return whole;
-    }
-    const chunks = [];
-    let total = 0;
-    for await (const chunk of { [Symbol.asyncIterator]: iterate.bind(streaming) }) {
-        total += chunk.length;
-        if (total > maxBytes) {
-            streaming.destroy?.();
-            throw oversizedObjectError(key, total, maxBytes);
-        }
-        chunks.push(chunk);
-    }
-    return concat(chunks, total);
-}

package/dist/shared/codec/s3/delete.d.ts

@@ -1,7 +0,0 @@
-import type { S3Client } from '@aws-sdk/client-s3';
-/**
- * Delete `keys` from `bucket` in chunks of 1000 (the DeleteObjects limit).
- * Returns the keys S3 reported as failed — never throws on per-key errors so
- * callers (orphan cleanup) can decide how loudly to react.
- */
-export declare function deleteObjects(client: S3Client, bucket: string, keys: string[]): Promise<string[]>;

package/dist/shared/codec/s3/delete.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteObjects = deleteObjects;
-const constants_1 = require("../../constants");
-const client_1 = require("./client");
-/**
- * Delete `keys` from `bucket` in chunks of 1000 (the DeleteObjects limit).
- * Returns the keys S3 reported as failed — never throws on per-key errors so
- * callers (orphan cleanup) can decide how loudly to react.
- */
-async function deleteObjects(client, bucket, keys) {
-    if (keys.length === 0)
-        return [];
-    const { DeleteObjectsCommand } = await (0, client_1.loadS3Sdk)();
-    const failed = [];
-    for (let offset = 0; offset < keys.length; offset += constants_1.S3_DELETE_BATCH_MAX) {
-        const chunk = keys.slice(offset, offset + constants_1.S3_DELETE_BATCH_MAX);
-        const response = await client.send(new DeleteObjectsCommand({
-            Bucket: bucket,
-            Delete: { Objects: chunk.map((key) => ({ Key: key })), Quiet: true },
-        }));
-        for (const error of response.Errors ?? []) {
-            if (error.Key)
-                failed.push(error.Key);
-        }
-    }
-    return failed;
-}

package/dist/shared/codec/s3/key-scope.d.ts

@@ -1,23 +0,0 @@
-/** base64url-encode one key part; the output alphabet never contains `/` or `.`. */
-export declare function encodeKeyPart(part: string): string;
-/**
- * The path every key `buildS3Key(prefix, [...parts, ...more])` shares: the
- * prefix plus the encoded `parts` joined by `/`, with neither `.bin` nor a
- * trailing `/`.
- */
-export declare function s3KeyScope(prefix: string, parts: readonly string[]): string;
-/**
- * True when `key` was produced by `buildS3Key` from exactly `parts`
- * (`<scope>.bin`) or from `parts` plus further parts (`<scope>/…`). An empty
- * `parts` degrades to a prefix-only check. Because parts are base64url-encoded
- * and joined by `/`, an identifier sharing a leading substring with another
- * (`t` and `t1`) never matches its scope.
- */
-export declare function isKeyInScope(key: string, prefix: string, parts: readonly string[]): boolean;
-/**
- * Refuse a row-sourced `s3Key` that lies outside the path the row's own
- * identifiers produce. A row is trusted for its shape, not for the object it
- * points at: a writer able to place one row in a partition must not be able
- * to make this library download or delete another tenant's object.
- */
-export declare function assertKeyInScope(key: string, prefix: string, parts: readonly string[]): void;

package/dist/shared/codec/s3/key-scope.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeKeyPart = encodeKeyPart;
-exports.s3KeyScope = s3KeyScope;
-exports.isKeyInScope = isKeyInScope;
-exports.assertKeyInScope = assertKeyInScope;
-const errors_1 = require("../../errors/errors");
-/** base64url-encode one key part; the output alphabet never contains `/` or `.`. */
-function encodeKeyPart(part) {
-    return Buffer.from(part, 'utf8').toString('base64url');
-}
-/**
- * The path every key `buildS3Key(prefix, [...parts, ...more])` shares: the
- * prefix plus the encoded `parts` joined by `/`, with neither `.bin` nor a
- * trailing `/`.
- */
-function s3KeyScope(prefix, parts) {
-    return `${prefix}${parts.map(encodeKeyPart).join('/')}`;
-}
-/**
- * True when `key` was produced by `buildS3Key` from exactly `parts`
- * (`<scope>.bin`) or from `parts` plus further parts (`<scope>/…`). An empty
- * `parts` degrades to a prefix-only check. Because parts are base64url-encoded
- * and joined by `/`, an identifier sharing a leading substring with another
- * (`t` and `t1`) never matches its scope.
- */
-function isKeyInScope(key, prefix, parts) {
-    const scope = s3KeyScope(prefix, parts);
-    if (parts.length === 0)
-        return key.startsWith(scope);
-    return key === `${scope}.bin` || key.startsWith(`${scope}/`);
-}
-/**
- * Refuse a row-sourced `s3Key` that lies outside the path the row's own
- * identifiers produce. A row is trusted for its shape, not for the object it
- * points at: a writer able to place one row in a partition must not be able
- * to make this library download or delete another tenant's object.
- */
-function assertKeyInScope(key, prefix, parts) {
-    if (isKeyInScope(key, prefix, parts))
-        return;
-    throw new errors_1.ValidationError(`s3Key "${key}" lies outside the S3 path this row may reference ` +
-        `("${s3KeyScope(prefix, parts)}"); refusing to touch an object the row does not own`, 's3Key');
-}

package/dist/shared/codec/s3/orphans.d.ts

@@ -1,23 +0,0 @@
-import type { Logger } from '../../logging/logger';
-import type { S3Offloader } from './offloader';
-/** Options for {@link cleanUpS3Orphans}. */
-export interface OrphanCleanupOptions {
-    rng?: () => number;
-    maxAttempts?: number;
-    signal?: AbortSignal;
-    /**
-     * The row's own leading key parts when `keys` were read back from a row.
-     * A key outside the path they produce is never deleted, only reported; own
-     * uploads (built by this call) pass no scope.
-     */
-    scope?: readonly string[];
-}
-/**
- * Best-effort delete of S3 objects orphaned by a failed DynamoDB write. Retries
- * transient errors with full-jitter backoff; on persistent failure or when S3
- * reports keys it could not delete, it logs at `warn` and never throws — the
- * sole non-throwing path in the library. There is no automatic backstop: an
- * S3 lifecycle rule sweeps the leftovers only if one was provisioned via
- * `ensureS3LifecycleRule()`, which is opt-in.
- */
-export declare function cleanUpS3Orphans(offloader: S3Offloader, keys: ReadonlyArray<string | undefined>, context: string, logger: Logger, options?: OrphanCleanupOptions): Promise<void>;

package/dist/shared/codec/s3/orphans.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanUpS3Orphans = cleanUpS3Orphans;
-const backoff_1 = require("../../dynamodb/backoff");
-const retry_1 = require("./retry");
-const DEFAULT_MAX_ATTEMPTS = 3;
-const BASE_DELAY_MS = 100;
-/**
- * Wait out one backoff window, cancellable via `options.signal`. Resolves `true`
- * when the signal aborts the wait (so the caller stops retrying) and `false`
- * otherwise — never rejects, preserving the best-effort, non-throwing contract.
- */
-async function backoffSleep(delayMs, options) {
-    try {
-        await (0, backoff_1.sleep)((0, backoff_1.fullJitter)(delayMs, options.rng), options.signal);
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
-/** Drop every key outside the row's scope, reporting each one. */
-function ownedOnly(offloader, keys, scope, context, logger) {
-    return keys.filter((key) => {
-        if (offloader.ownsKey(key, scope))
-            return true;
-        logger.warn(`${context}: refusing to delete an S3 object outside this row's scope`, { key });
-        return false;
-    });
-}
-/** The non-empty keys, restricted to the row's scope when one is given. */
-function selectOrphans(offloader, keys, context, logger, options) {
-    const present = keys.filter((key) => typeof key === 'string' && key.length > 0);
-    return options.scope ? ownedOnly(offloader, present, options.scope, context, logger) : present;
-}
-/**
- * Best-effort delete of S3 objects orphaned by a failed DynamoDB write. Retries
- * transient errors with full-jitter backoff; on persistent failure or when S3
- * reports keys it could not delete, it logs at `warn` and never throws — the
- * sole non-throwing path in the library. There is no automatic backstop: an
- * S3 lifecycle rule sweeps the leftovers only if one was provisioned via
- * `ensureS3LifecycleRule()`, which is opt-in.
- */
-async function cleanUpS3Orphans(offloader, keys, context, logger, options = {}) {
-    const orphans = selectOrphans(offloader, keys, context, logger, options);
-    if (orphans.length === 0)
-        return;
-    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-    let delay = BASE_DELAY_MS;
-    let lastError = new Error('S3 orphan cleanup did not run');
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            const failed = await offloader.deleteBatch(orphans);
-            if (failed.length === 0)
-                return;
-            logger.warn(`Some orphaned S3 objects could not be deleted after ${context}; a lifecycle rule from ensureS3LifecycleRule() would sweep them, otherwise clean up manually`, { failedCount: failed.length });
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt >= maxAttempts || !(0, retry_1.isTransientS3Error)(lastError))
-                break;
-            if (await backoffSleep(delay, options))
-                break;
-            delay = (0, backoff_1.nextBackoffDelay)(delay);
-        }
-    }
-    logger.warn(`Failed to clean up orphaned S3 objects after ${context}; a lifecycle rule from ensureS3LifecycleRule() would sweep them, otherwise clean up manually`, {
-        message: lastError.message,
-    });
-}

package/dist/shared/codec/s3/read-write.d.ts

@@ -1,18 +0,0 @@
-import type { S3Client } from '@aws-sdk/client-s3';
-/** Parameters for {@link uploadObject}. */
-export interface UploadParams {
-    bucket: string;
-    key: string;
-    data: Uint8Array;
-    serverSideEncryption?: string;
-    sseKmsKeyId?: string;
-}
-/** Upload `data` to S3, wrapping failures as `S3_OFFLOAD_FAILED`. */
-export declare function uploadObject(client: S3Client, params: UploadParams): Promise<void>;
-/**
- * Download an object's bytes, wrapping failures/empty bodies as
- * `S3_OFFLOAD_FAILED`. An object over `maxBytes` is refused from its declared
- * `ContentLength` before the body is touched, or while streaming when the
- * length is unknown, so a replaced or hostile object can never exhaust memory.
- */
-export declare function downloadObject(client: S3Client, bucket: string, key: string, maxBytes: number): Promise<Uint8Array>;

package/dist/shared/codec/s3/read-write.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadObject = uploadObject;
-exports.downloadObject = downloadObject;
-const retry_1 = require("../../dynamodb/retry");
-const base_error_1 = require("../../errors/base-error");
-const error_code_1 = require("../../errors/error-code");
-const bounded_body_1 = require("./bounded-body");
-const client_1 = require("./client");
-const retry_2 = require("./retry");
-/** Upload `data` to S3, wrapping failures as `S3_OFFLOAD_FAILED`. */
-async function uploadObject(client, params) {
-    const { PutObjectCommand } = await (0, client_1.loadS3Sdk)();
-    try {
-        await (0, retry_1.withRetry)(() => client.send(new PutObjectCommand({
-            Bucket: params.bucket,
-            Key: params.key,
-            Body: params.data,
-            ContentType: 'application/octet-stream',
-            ServerSideEncryption: params.serverSideEncryption,
-            ...(params.sseKmsKeyId ? { SSEKMSKeyId: params.sseKmsKeyId } : {}),
-        })), { maxAttempts: 3, isRetryable: retry_2.isTransientS3Error });
-    }
-    catch (error) {
-        throw new base_error_1.DynamoDBLangGraphError(error.message, error_code_1.ErrorCode.S3_OFFLOAD_FAILED, { operation: 'upload', key: params.key }, error);
-    }
-}
-/**
- * Download an object's bytes, wrapping failures/empty bodies as
- * `S3_OFFLOAD_FAILED`. An object over `maxBytes` is refused from its declared
- * `ContentLength` before the body is touched, or while streaming when the
- * length is unknown, so a replaced or hostile object can never exhaust memory.
- */
-async function downloadObject(client, bucket, key, maxBytes) {
-    const { GetObjectCommand } = await (0, client_1.loadS3Sdk)();
-    try {
-        return await (0, retry_1.withRetry)(async () => {
-            const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
-            if (typeof response.ContentLength === 'number' && response.ContentLength > maxBytes) {
-                throw (0, bounded_body_1.oversizedObjectError)(key, response.ContentLength, maxBytes);
-            }
-            if (!response.Body) {
-                throw new Error(`S3 object body is empty for key: ${key}`);
-            }
-            return (0, bounded_body_1.readBodyBounded)(response.Body, key, maxBytes);
-        }, { maxAttempts: 3, isRetryable: retry_2.isTransientS3Error });
-    }
-    catch (error) {
-        throw new base_error_1.DynamoDBLangGraphError(error.message, error_code_1.ErrorCode.S3_OFFLOAD_FAILED, { operation: 'download', key }, error);
-    }
-}

package/dist/shared/codec/s3/retry.d.ts

@@ -1,5 +0,0 @@
-/**
- * True when `error` looks like a transient S3 failure worth retrying — the one
- * classifier for uploads, downloads and orphan cleanup.
- */
-export declare function isTransientS3Error(error: Error): boolean;

package/dist/shared/codec/s3/retry.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTransientS3Error = isTransientS3Error;
-const retry_classifier_1 = require("../../dynamodb/retry-classifier");
-/**
- * Transient S3 signals: everything the DynamoDB classifier already treats as
- * transient (the SDK transport `TimeoutError`, socket errors, `RequestTimeout`,
- * `ServiceUnavailable`, …) plus the two names only S3 uses. HTTP 429/5xx and
- * the `$retryable` trait are recognised by the shared classifier itself.
- */
-const RETRYABLE_S3_SIGNALS = [
-    ...retry_classifier_1.DEFAULT_RETRYABLE_ERRORS,
-    'SlowDown',
-    'InternalError',
-];
-/**
- * True when `error` looks like a transient S3 failure worth retrying — the one
- * classifier for uploads, downloads and orphan cleanup.
- */
-function isTransientS3Error(error) {
-    return (0, retry_classifier_1.isRetryableError)(error, RETRYABLE_S3_SIGNALS);
-}