@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -32,10 +32,9 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
                 this.serializer.write(15, {});
                 request.body = this.serializer.flush();
             }
-            try {
+            if (request.body instanceof Uint8Array) {
                 request.headers["content-length"] = String(request.body.byteLength);
             }
-            catch (ignored) { }
         }
         const { service, operation } = getSmithyContext(context);
         const path = `/service/${service}/operation/${operation}`;

package/node_modules/@smithy/core/dist-es/submodules/cbor/cbor-encode.js

@@ -59,7 +59,7 @@ export function encode(_input) {
             ensureSpace(64);
         }
         if (typeof input === "number") {
-            if (Number.isInteger(input)) {
+            if (Number.isInteger(input) && input >= -0x20000000000000 && input <= 0x1fffffffffffff) {
                 const nonNegative = input >= 0;
                 const major = nonNegative ? majorUint64 : majorNegativeInt64;
                 const value = nonNegative ? input : -input - 1;

package/node_modules/@smithy/core/dist-es/submodules/cbor/codec-v1/CborShapeDeserializer.js

@@ -0,0 +1,113 @@
+import { SerdeContext } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { NumericValue, _parseEpochTimestamp, fromBase64 } from "@smithy/core/serde";
+import { cbor } from "../cbor";
+export class CborShapeDeserializer extends SerdeContext {
+    read(schema, bytes) {
+        const data = cbor.deserialize(bytes);
+        return this.readValue(schema, data);
+    }
+    readValue(_schema, value) {
+        const ns = NormalizedSchema.of(_schema);
+        if (ns.isTimestampSchema()) {
+            if (typeof value === "number") {
+                return _parseEpochTimestamp(value);
+            }
+            if (typeof value === "object") {
+                if (value.tag === 1 && "value" in value) {
+                    return _parseEpochTimestamp(value.value);
+                }
+            }
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof value === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
+            }
+            return value;
+        }
+        if (typeof value === "undefined" ||
+            typeof value === "boolean" ||
+            typeof value === "number" ||
+            typeof value === "string" ||
+            typeof value === "bigint" ||
+            typeof value === "symbol") {
+            return value;
+        }
+        else if (typeof value === "object") {
+            if (value === null) {
+                return null;
+            }
+            if ("byteLength" in value) {
+                return value;
+            }
+            if (value instanceof Date) {
+                return value;
+            }
+            if (ns.isDocumentSchema()) {
+                return value;
+            }
+            if (ns.isListSchema()) {
+                const newArray = [];
+                const memberSchema = ns.getValueSchema();
+                for (const item of value) {
+                    const itemValue = this.readValue(memberSchema, item);
+                    newArray.push(itemValue);
+                }
+                return newArray;
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const targetSchema = ns.getValueSchema();
+                for (const key in value) {
+                    const itemValue = this.readValue(targetSchema, value[key]);
+                    newObject[key] = itemValue;
+                }
+            }
+            else if (ns.isStructSchema()) {
+                const isUnion = ns.isUnionSchema();
+                let keys;
+                if (isUnion) {
+                    keys = new Set();
+                    for (const k in value) {
+                        if (k !== "__type") {
+                            keys.add(k);
+                        }
+                    }
+                }
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    if (isUnion) {
+                        keys.delete(key);
+                    }
+                    if (value[key] != null) {
+                        newObject[key] = this.readValue(memberSchema, value[key]);
+                    }
+                }
+                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 in value) {
+                        if (!(k in newObject)) {
+                            newObject[k] = value[k];
+                        }
+                    }
+                }
+            }
+            else if (value instanceof NumericValue) {
+                return value;
+            }
+            return newObject;
+        }
+        else {
+            return value;
+        }
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/cbor/codec-v1/CborShapeSerializer.js

@@ -0,0 +1,103 @@
+import { SerdeContext } from "@smithy/core/protocols";
+import { NormalizedSchema } from "@smithy/core/schema";
+import { fromBase64, generateIdempotencyToken } from "@smithy/core/serde";
+import { cbor } from "../cbor";
+import { dateToTag } from "../parseCborBody";
+export class CborShapeSerializer extends SerdeContext {
+    value;
+    write(schema, value) {
+        this.value = this.serialize(schema, value);
+    }
+    serialize(schema, source) {
+        const ns = NormalizedSchema.of(schema);
+        if (source == null) {
+            if (ns.isIdempotencyToken()) {
+                return generateIdempotencyToken();
+            }
+            return source;
+        }
+        if (ns.isBlobSchema()) {
+            if (typeof source === "string") {
+                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
+            }
+            return source;
+        }
+        if (ns.isTimestampSchema()) {
+            if (typeof source === "number" || typeof source === "bigint") {
+                return dateToTag(new Date((Number(source) / 1000) | 0));
+            }
+            return dateToTag(source);
+        }
+        if (typeof source === "function" || typeof source === "object") {
+            const sourceObject = source;
+            if (ns.isListSchema() && Array.isArray(sourceObject)) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                const newArray = [];
+                let i = 0;
+                for (const item of sourceObject) {
+                    const value = this.serialize(ns.getValueSchema(), item);
+                    if (value != null || sparse) {
+                        newArray[i++] = value;
+                    }
+                }
+                return newArray;
+            }
+            if (sourceObject instanceof Date) {
+                return dateToTag(sourceObject);
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const sparse = !!ns.getMergedTraits().sparse;
+                for (const key in sourceObject) {
+                    const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                    if (value != null || sparse) {
+                        newObject[key] = value;
+                    }
+                }
+            }
+            else if (ns.isStructSchema()) {
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    const value = this.serialize(memberSchema, sourceObject[key]);
+                    if (value != null) {
+                        newObject[key] = value;
+                    }
+                }
+                const isUnion = ns.isUnionSchema();
+                if (isUnion && Array.isArray(sourceObject.$unknown)) {
+                    const [k, v] = sourceObject.$unknown;
+                    newObject[k] = v;
+                }
+                else if (typeof sourceObject.__type === "string") {
+                    for (const k in sourceObject) {
+                        if (!(k in newObject)) {
+                            newObject[k] = this.serialize(15, sourceObject[k]);
+                        }
+                    }
+                }
+            }
+            else if (ns.isDocumentSchema()) {
+                if (Array.isArray(sourceObject)) {
+                    const newArray = [];
+                    let i = 0;
+                    for (const item of sourceObject) {
+                        newArray[i++] = this.serialize(ns.getValueSchema(), item);
+                    }
+                    return newArray;
+                }
+                for (const key in sourceObject) {
+                    newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
+                }
+            }
+            else if (ns.isBigDecimalSchema()) {
+                return sourceObject;
+            }
+            return newObject;
+        }
+        return source;
+    }
+    flush() {
+        const buffer = cbor.serialize(this.value);
+        this.value = undefined;
+        return buffer;
+    }
+}