agent-relay 4.0.32 → 4.0.34

package/node_modules/@relayfile/local-mount/node_modules/readdirp/index.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaddirpStream = exports.EntryTypes = void 0;
+exports.readdirp = readdirp;
+exports.readdirpPromise = readdirpPromise;
+const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const node_path_1 = require("node:path");
+exports.EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: exports.EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+class ReaddirpStream extends node_stream_1.Readable {
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? promises_1.lstat : promises_1.stat;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === exports.EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, node_path_1.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename));
+            entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await (0, promises_1.realpath)(full);
+                const entryRealPathStats = await (0, promises_1.lstat)(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path_1.sep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+exports.ReaddirpStream = ReaddirpStream;
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = exports.EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+function readdirpPromise(root, options = {}) {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        readdirp(root, options)
+            .on('data', (entry) => files.push(entry))
+            .on('end', () => resolve(files))
+            .on('error', (error) => reject(error));
+    });
+}
+exports.default = readdirp;

package/node_modules/@relayfile/local-mount/node_modules/readdirp/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "readdirp",
+  "description": "Recursive version of fs.readdir with small RAM & CPU footprint.",
+  "version": "4.1.2",
+  "homepage": "https://github.com/paulmillr/readdirp",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/paulmillr/readdirp.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/paulmillr/readdirp/issues"
+  },
+  "author": "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+  "contributors": [
+    "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+    "Paul Miller (https://paulmillr.com)"
+  ],
+  "engines": {
+    "node": ">= 14.18.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js.map",
+    "esm"
+  ],
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    }
+  },
+  "sideEffects": false,
+  "keywords": [
+    "recursive",
+    "fs",
+    "stream",
+    "streams",
+    "readdir",
+    "filesystem",
+    "find",
+    "filter"
+  ],
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "lint": "prettier --check index.ts test/index.test.js",
+    "format": "prettier --write index.ts test/index.test.js",
+    "test": "node test/index.test.js",
+    "test:coverage": "c8 node test/index.test.js"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.3.1",
+    "@types/node": "20.14.8",
+    "c8": "10.1.3",
+    "chai": "4.3.4",
+    "chai-subset": "1.6.0",
+    "micro-should": "0.5.0",
+    "prettier": "3.1.1",
+    "typescript": "5.5.2"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://paulmillr.com/funding/"
+  }
+}

package/node_modules/@relayfile/local-mount/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@relayfile/local-mount",
+  "version": "0.2.2",
+  "description": "Create a symlink/copy mount of a project directory with .agentignore/.agentreadonly semantics, then launch a CLI inside it and sync writable changes back on exit",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "ignore": "^7.0.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AgentWorkforce/relayfile",
+    "directory": "packages/local-mount"
+  },
+  "license": "MIT",
+  "keywords": [
+    "relayfile",
+    "mount",
+    "symlink",
+    "agent",
+    "sandbox",
+    "agentignore",
+    "agentreadonly"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/node_modules/@smithy/config-resolver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/config-resolver",
-  "version": "4.4.16",
+  "version": "4.4.17",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline config-resolver",
@@ -27,7 +27,7 @@
     "@smithy/node-config-provider": "^4.3.14",
     "@smithy/types": "^4.14.1",
     "@smithy/util-config-provider": "^4.2.2",
-    "@smithy/util-endpoints": "^3.4.1",
+    "@smithy/util-endpoints": "^3.4.2",
     "@smithy/util-middleware": "^4.2.14",
     "tslib": "^2.6.2"
   },

package/node_modules/@smithy/core/dist-cjs/index.js

@@ -204,7 +204,8 @@ function setFeature(context, feature, value) {
 class DefaultIdentityProviderConfig {
     authSchemes = new Map();
     constructor(config) {
-        for (const [key, value] of Object.entries(config)) {
+        for (const key in config) {
+            const value = config[key];
             if (value !== undefined) {
                 this.authSchemes.set(key, value);
             }

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -745,7 +745,13 @@ const loadSmithyRpcV2CborErrorCode = (output, data) => {
     if (data["__type"] !== undefined) {
         return sanitizeErrorCode(data["__type"]);
     }
-    const codeKey = Object.keys(data).find((key) => key.toLowerCase() === "code");
+    let codeKey;
+    for (const key in data) {
+        if (key.toLowerCase() === "code") {
+            codeKey = key;
+            break;
+        }
+    }
     if (codeKey && data[codeKey] !== undefined) {
         return sanitizeErrorCode(data[codeKey]);
     }
@@ -772,8 +778,8 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
         contents.hostname = resolvedHostname;
     }
     if (endpoint.headers) {
-        for (const [name, value] of Object.entries(endpoint.headers)) {
-            contents.headers[name] = value;
+        for (const name in endpoint.headers) {
+            contents.headers[name] = endpoint.headers[name];
         }
     }
     if (body !== undefined) {
@@ -843,7 +849,7 @@ class CborShapeSerializer extends protocols.SerdeContext {
             const newObject = {};
             if (ns.isMapSchema()) {
                 const sparse = !!ns.getMergedTraits().sparse;
-                for (const key of Object.keys(sourceObject)) {
+                for (const key in sourceObject) {
                     const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
                     if (value != null || sparse) {
                         newObject[key] = value;
@@ -863,15 +869,15 @@ class CborShapeSerializer extends protocols.SerdeContext {
                     newObject[k] = v;
                 }
                 else if (typeof sourceObject.__type === "string") {
-                    for (const [k, v] of Object.entries(sourceObject)) {
+                    for (const k in sourceObject) {
                         if (!(k in newObject)) {
-                            newObject[k] = this.serialize(15, v);
+                            newObject[k] = this.serialize(15, sourceObject[k]);
                         }
                     }
                 }
             }
             else if (ns.isDocumentSchema()) {
-                for (const key of Object.keys(sourceObject)) {
+                for (const key in sourceObject) {
                     newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
                 }
             }
@@ -944,7 +950,7 @@ class CborShapeDeserializer extends protocols.SerdeContext {
             const newObject = {};
             if (ns.isMapSchema()) {
                 const targetSchema = ns.getValueSchema();
-                for (const key of Object.keys(value)) {
+                for (const key in value) {
                     const itemValue = this.readValue(targetSchema, value[key]);
                     newObject[key] = itemValue;
                 }
@@ -953,7 +959,12 @@ class CborShapeDeserializer extends protocols.SerdeContext {
                 const isUnion = ns.isUnionSchema();
                 let keys;
                 if (isUnion) {
-                    keys = new Set(Object.keys(value).filter((k) => k !== "__type"));
+                    keys = new Set();
+                    for (const k in value) {
+                        if (k !== "__type") {
+                            keys.add(k);
+                        }
+                    }
                 }
                 for (const [key, memberSchema] of ns.structIterator()) {
                     if (isUnion) {
@@ -963,14 +974,21 @@ class CborShapeDeserializer extends protocols.SerdeContext {
                         newObject[key] = this.readValue(memberSchema, value[key]);
                     }
                 }
-                if (isUnion && keys?.size === 1 && Object.keys(newObject).length === 0) {
-                    const k = keys.values().next().value;
-                    newObject.$unknown = [k, value[k]];
+                if (isUnion && keys?.size === 1) {
+                    let newObjectEmpty = true;
+                    for (const _ in newObject) {
+                        newObjectEmpty = false;
+                        break;
+                    }
+                    if (newObjectEmpty) {
+                        const k = keys.values().next().value;
+                        newObject.$unknown = [k, value[k]];
+                    }
                 }
                 else if (typeof value.__type === "string") {
-                    for (const [k, v] of Object.entries(value)) {
+                    for (const k in value) {
                         if (!(k in newObject)) {
-                            newObject[k] = v;
+                            newObject[k] = value[k];
                         }
                     }
                 }

package/node_modules/@smithy/core/dist-cjs/submodules/endpoints/index.js

@@ -8,8 +8,8 @@ const toEndpointV1 = (endpoint) => {
             const v1Endpoint = urlParser.parseUrl(endpoint.url);
             if (endpoint.headers) {
                 v1Endpoint.headers = {};
-                for (const [name, values] of Object.entries(endpoint.headers)) {
-                    v1Endpoint.headers[name.toLowerCase()] = values.join(", ");
+                for (const name in endpoint.headers) {
+                    v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
                 }
             }
             return v1Endpoint;

package/node_modules/@smithy/core/dist-cjs/submodules/event-streams/index.js

@@ -50,9 +50,13 @@ class EventStreamSerde {
                     body: event.body,
                 };
             }
-            const unionMember = Object.keys(event).find((key) => {
-                return key !== "__type";
-            }) ?? "";
+            let unionMember = "";
+            for (const key in event) {
+                if (key !== "__type") {
+                    unionMember = key;
+                    break;
+                }
+            }
             const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
             const headers = {
                 ":event-type": { type: "string", value: eventType },
@@ -73,9 +77,13 @@ class EventStreamSerde {
         const memberSchemas = unionSchema.getMemberSchemas();
         const initialResponseMarker = Symbol("initialResponseMarker");
         const asyncIterable = marshaller.deserialize(response.body, async (event) => {
-            const unionMember = Object.keys(event).find((key) => {
-                return key !== "__type";
-            }) ?? "";
+            let unionMember = "";
+            for (const key in event) {
+                if (key !== "__type") {
+                    unionMember = key;
+                    break;
+                }
+            }
             const body = event[unionMember].body;
             if (unionMember === "initial-response") {
                 const dataObject = await this.deserializer.read(responseSchema, body);
@@ -151,8 +159,8 @@ class EventStreamSerde {
             if (!responseSchema) {
                 throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
             }
-            for (const [key, value] of Object.entries(firstEvent.value)) {
-                initialResponseContainer[key] = value;
+            for (const key in firstEvent.value) {
+                initialResponseContainer[key] = firstEvent.value[key];
             }
         }
         return {

package/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -72,8 +72,8 @@ class HttpProtocol extends SerdeContext {
                 request.query[k] = v;
             }
             if (endpoint.headers) {
-                for (const [name, values] of Object.entries(endpoint.headers)) {
-                    request.headers[name] = values.join(", ");
+                for (const name in endpoint.headers) {
+                    request.headers[name] = endpoint.headers[name].join(", ");
                 }
             }
             return request;
@@ -87,8 +87,8 @@ class HttpProtocol extends SerdeContext {
                 ...endpoint.query,
             };
             if (endpoint.headers) {
-                for (const [name, value] of Object.entries(endpoint.headers)) {
-                    request.headers[name] = value;
+                for (const name in endpoint.headers) {
+                    request.headers[name] = endpoint.headers[name];
                 }
             }
             return request;
@@ -103,8 +103,10 @@ class HttpProtocol extends SerdeContext {
         if (opTraits.endpoint) {
             let hostPrefix = opTraits.endpoint?.[0];
             if (typeof hostPrefix === "string") {
-                const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
-                for (const [name] of hostLabelInputs) {
+                for (const [name, member] of inputNs.structIterator()) {
+                    if (!member.getMergedTraits().hostLabel) {
+                        continue;
+                    }
                     const replacement = input[name];
                     if (typeof replacement !== "string") {
                         throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
@@ -200,7 +202,9 @@ class HttpBindingProtocol extends HttpProtocol {
                     request.path += path;
                 }
                 const traitSearchParams = new URLSearchParams(search ?? "");
-                Object.assign(query, Object.fromEntries(traitSearchParams));
+                for (const [key, value] of traitSearchParams) {
+                    query[key] = value;
+                }
             }
         }
         for (const [memberName, memberNs] of ns.structIterator()) {
@@ -250,7 +254,8 @@ class HttpBindingProtocol extends HttpProtocol {
                 headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
             }
             else if (typeof memberTraits.httpPrefixHeaders === "string") {
-                for (const [key, val] of Object.entries(inputMemberValue)) {
+                for (const key in inputMemberValue) {
+                    const val = inputMemberValue[key];
                     const amalgam = memberTraits.httpPrefixHeaders + key;
                     serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
                     headers[amalgam.toLowerCase()] = serializer.flush();
@@ -295,8 +300,9 @@ class HttpBindingProtocol extends HttpProtocol {
         const serializer = this.serializer;
         const traits = ns.getMergedTraits();
         if (traits.httpQueryParams) {
-            for (const [key, val] of Object.entries(data)) {
+            for (const key in data) {
                 if (!(key in query)) {
+                    const val = data[key];
                     const valueSchema = ns.getValueSchema();
                     Object.assign(valueSchema.getMergedTraits(), {
                         ...traits,
@@ -424,8 +430,9 @@ class HttpBindingProtocol extends HttpProtocol {
             }
             else if (memberTraits.httpPrefixHeaders !== undefined) {
                 dataObject[memberName] = {};
-                for (const [header, value] of Object.entries(response.headers)) {
+                for (const header in response.headers) {
                     if (header.startsWith(memberTraits.httpPrefixHeaders)) {
+                        const value = response.headers[header];
                         const valueSchema = memberSchema.getValueSchema();
                         valueSchema.getMergedTraits().httpHeader = header;
                         dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -655,7 +655,12 @@ class TypeRegistry {
         return undefined;
     }
     find(predicate) {
-        return [...this.schemas.values()].find(predicate);
+        for (const schema of this.schemas.values()) {
+            if (predicate(schema)) {
+                return schema;
+            }
+        }
+        return undefined;
     }
     clear() {
         this.schemas.clear();