@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/@earendil-works/pi-tui/dist/tui-main-screen.js

@@ -4,6 +4,64 @@ import { deleteKittyImage, isImageLine } from "./terminal-image.js";
 import { TuiBase } from "./tui.js";
 import { visibleWidth } from "./utils.js";
 const KITTY_SEQUENCE_PREFIX = "\x1b_G";
+const MAX_RENDER_WRITE_CHARS = 1024 * 1024;
+/**
+ * Streams terminal output in 1 MiB chunks so a full render never forms one string large enough to exceed V8's limit.
+ *
+ * `append()` fills the current chunk and flushes it when full. Oversized input is split at chunk boundaries, preserving
+ * surrogate pairs so each write remains valid UTF-16. Callers append synchronized-output begin/end sequences themselves;
+ * the final `flush()` writes any remainder, including the end sequence.
+ */
+class BoundedTerminalWriter {
+    buffer = "";
+    writtenChars = 0;
+    write;
+    constructor(write) {
+        this.write = write;
+    }
+    /**
+     * Append terminal data, flushing full chunks as needed. Callers must call `flush()` after the final append.
+     * @param value Terminal data to write in order; oversized values are split without splitting surrogate pairs.
+     */
+    append(value) {
+        let offset = 0;
+        while (offset < value.length) {
+            const capacity = MAX_RENDER_WRITE_CHARS - this.buffer.length;
+            if (capacity === 0) {
+                this.flush();
+                continue;
+            }
+            let end = Math.min(value.length, offset + capacity);
+            if (end < value.length &&
+                value.charCodeAt(end - 1) >= 0xd800 &&
+                value.charCodeAt(end - 1) <= 0xdbff &&
+                value.charCodeAt(end) >= 0xdc00 &&
+                value.charCodeAt(end) <= 0xdfff) {
+                end--;
+            }
+            if (end === offset) {
+                this.flush();
+                continue;
+            }
+            this.buffer += value.slice(offset, end);
+            offset = end;
+            if (this.buffer.length === MAX_RENDER_WRITE_CHARS) {
+                this.flush();
+            }
+        }
+    }
+    /** Write the current chunk, if any, and retain only its character count for debug output. */
+    flush() {
+        if (!this.buffer)
+            return;
+        this.write(this.buffer);
+        this.writtenChars += this.buffer.length;
+        this.buffer = "";
+    }
+    get length() {
+        return this.writtenChars + this.buffer.length;
+    }
+}
 function parseKittyImageHeader(line) {
     const sequenceStart = line.indexOf(KITTY_SEQUENCE_PREFIX);
     if (sequenceStart === -1)
@@ -178,31 +236,32 @@ export class TuiMainScreen extends TuiBase {
         // Helper to clear scrollback and viewport and render all new lines
         const fullRender = (clear) => {
             this.fullRedrawCount += 1;
-            let buffer = "\x1b[?2026h"; // Begin synchronized output
+            const output = new BoundedTerminalWriter((data) => this.terminal.write(data));
+            output.append("\x1b[?2026h"); // Begin synchronized output
             if (clear) {
-                buffer += this.deleteKittyImages(this.previousKittyImageIds);
-                buffer += "\x1b[2J\x1b[H\x1b[3J"; // Clear screen, home, then clear scrollback
+                output.append(this.deleteKittyImages(this.previousKittyImageIds));
+                output.append("\x1b[2J\x1b[H\x1b[3J"); // Clear screen, home, then clear scrollback
             }
             for (let i = 0; i < newLines.length; i++) {
                 if (i > 0)
-                    buffer += "\r\n";
+                    output.append("\r\n");
                 const line = newLines[i];
                 const isImage = isImageLine(line);
                 const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i) : 1;
                 if (imageReservedRows > 1 && imageReservedRows <= height) {
                     for (let row = 1; row < imageReservedRows; row++) {
-                        buffer += "\r\n";
+                        output.append("\r\n");
                     }
-                    buffer += `\x1b[${imageReservedRows - 1}A`;
-                    buffer += line;
-                    buffer += `\x1b[${imageReservedRows - 1}B`;
+                    output.append(`\x1b[${imageReservedRows - 1}A`);
+                    output.append(line);
+                    output.append(`\x1b[${imageReservedRows - 1}B`);
                     i += imageReservedRows - 1;
                     continue;
                 }
-                buffer += line;
+                output.append(line);
             }
-            buffer += "\x1b[?2026l"; // End synchronized output
-            this.terminal.write(buffer);
+            output.append("\x1b[?2026l"); // End synchronized output
+            output.flush();
             this.cursorRow = Math.max(0, newLines.length - 1);
             this.hardwareCursorRow = this.cursorRow;
             // Reset max lines when clearing, otherwise track growth
@@ -294,8 +353,9 @@ export class TuiMainScreen extends TuiBase {
         // All changes are in deleted lines (nothing to render, just clear)
         if (firstChanged >= newLines.length) {
             if (this.previousLines.length > newLines.length) {
-                let buffer = "\x1b[?2026h";
-                buffer += this.deleteChangedKittyImages(firstChanged, lastChanged);
+                const output = new BoundedTerminalWriter((data) => this.terminal.write(data));
+                output.append("\x1b[?2026h");
+                output.append(this.deleteChangedKittyImages(firstChanged, lastChanged));
                 // Move to end of new content (clamp to 0 for empty content)
                 const targetRow = Math.max(0, newLines.length - 1);
                 if (targetRow < prevViewportTop) {
@@ -305,10 +365,10 @@ export class TuiMainScreen extends TuiBase {
                 }
                 const lineDiff = computeLineDiff(targetRow);
                 if (lineDiff > 0)
-                    buffer += `\x1b[${lineDiff}B`;
+                    output.append(`\x1b[${lineDiff}B`);
                 else if (lineDiff < 0)
-                    buffer += `\x1b[${-lineDiff}A`;
-                buffer += "\r";
+                    output.append(`\x1b[${-lineDiff}A`);
+                output.append("\r");
                 // Clear extra lines without scrolling
                 const extraLines = this.previousLines.length - newLines.length;
                 if (extraLines > height) {
@@ -318,19 +378,19 @@ export class TuiMainScreen extends TuiBase {
                 }
                 const clearStartOffset = newLines.length === 0 ? 0 : 1;
                 if (extraLines > 0 && clearStartOffset > 0) {
-                    buffer += `\x1b[${clearStartOffset}B`;
+                    output.append(`\x1b[${clearStartOffset}B`);
                 }
                 for (let i = 0; i < extraLines; i++) {
-                    buffer += "\r\x1b[2K";
+                    output.append("\r\x1b[2K");
                     if (i < extraLines - 1)
-                        buffer += "\x1b[1B";
+                        output.append("\x1b[1B");
                 }
                 const moveBack = Math.max(0, extraLines - 1 + clearStartOffset);
                 if (moveBack > 0) {
-                    buffer += `\x1b[${moveBack}A`;
+                    output.append(`\x1b[${moveBack}A`);
                 }
-                buffer += "\x1b[?2026l";
-                this.terminal.write(buffer);
+                output.append("\x1b[?2026l");
+                output.flush();
                 this.cursorRow = targetRow;
                 this.hardwareCursorRow = targetRow;
             }
@@ -350,19 +410,20 @@ export class TuiMainScreen extends TuiBase {
             return;
         }
         // Render from first changed line to end
-        // Build buffer with all updates wrapped in synchronized output
-        let buffer = "\x1b[?2026h"; // Begin synchronized output
-        buffer += this.deleteChangedKittyImages(firstChanged, lastChanged);
+        // Keep updates wrapped in synchronized output while writing bounded chunks.
+        const output = new BoundedTerminalWriter((data) => this.terminal.write(data));
+        output.append("\x1b[?2026h"); // Begin synchronized output
+        output.append(this.deleteChangedKittyImages(firstChanged, lastChanged));
         const prevViewportBottom = prevViewportTop + height - 1;
         const moveTargetRow = appendStart ? firstChanged - 1 : firstChanged;
         if (moveTargetRow > prevViewportBottom) {
             const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - prevViewportTop));
             const moveToBottom = height - 1 - currentScreenRow;
             if (moveToBottom > 0) {
-                buffer += `\x1b[${moveToBottom}B`;
+                output.append(`\x1b[${moveToBottom}B`);
             }
             const scroll = moveTargetRow - prevViewportBottom;
-            buffer += "\r\n".repeat(scroll);
+            output.append("\r\n".repeat(scroll));
             prevViewportTop += scroll;
             viewportTop += scroll;
             hardwareCursorRow = moveTargetRow;
@@ -370,18 +431,18 @@ export class TuiMainScreen extends TuiBase {
         // Move cursor to first changed line (use hardwareCursorRow for actual position)
         const lineDiff = computeLineDiff(moveTargetRow);
         if (lineDiff > 0) {
-            buffer += `\x1b[${lineDiff}B`; // Move down
+            output.append(`\x1b[${lineDiff}B`); // Move down
         }
         else if (lineDiff < 0) {
-            buffer += `\x1b[${-lineDiff}A`; // Move up
+            output.append(`\x1b[${-lineDiff}A`); // Move up
         }
-        buffer += appendStart ? "\r\n" : "\r"; // Move to column 0
+        output.append(appendStart ? "\r\n" : "\r"); // Move to column 0
         // Only render changed lines (firstChanged to lastChanged), not all lines to end
         // This reduces flicker when only a single line changes (e.g., spinner animation)
         const renderEnd = Math.min(lastChanged, newLines.length - 1);
         for (let i = firstChanged; i <= renderEnd; i++) {
             if (i > firstChanged)
-                buffer += "\r\n";
+                output.append("\r\n");
             const line = newLines[i];
             const isImage = isImageLine(line);
             const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i, renderEnd) : 1;
@@ -392,17 +453,17 @@ export class TuiMainScreen extends TuiBase {
                     fullRender(true);
                     return;
                 }
-                buffer += "\x1b[2K";
+                output.append("\x1b[2K");
                 for (let row = 1; row < imageReservedRows; row++) {
-                    buffer += "\r\n\x1b[2K";
+                    output.append("\r\n\x1b[2K");
                 }
-                buffer += `\x1b[${imageReservedRows - 1}A`;
-                buffer += line;
-                buffer += `\x1b[${imageReservedRows - 1}B`;
+                output.append(`\x1b[${imageReservedRows - 1}A`);
+                output.append(line);
+                output.append(`\x1b[${imageReservedRows - 1}B`);
                 i += imageReservedRows - 1;
                 continue;
             }
-            buffer += "\x1b[2K"; // Clear current line
+            output.append("\x1b[2K"); // Clear current line
             if (!isImage && visibleWidth(line) > width) {
                 // Log all lines to crash file for debugging
                 const crashLogPath = path.join(this.logDirectory, "sling-crash.log");
@@ -429,7 +490,7 @@ export class TuiMainScreen extends TuiBase {
                 ].join("\n");
                 throw new Error(errorMsg);
             }
-            buffer += line;
+            output.append(line);
         }
         // Track where cursor ended up after rendering
         let finalCursorRow = renderEnd;
@@ -438,17 +499,17 @@ export class TuiMainScreen extends TuiBase {
             // Move to end of new content first if we stopped before it
             if (renderEnd < newLines.length - 1) {
                 const moveDown = newLines.length - 1 - renderEnd;
-                buffer += `\x1b[${moveDown}B`;
+                output.append(`\x1b[${moveDown}B`);
                 finalCursorRow = newLines.length - 1;
             }
             const extraLines = this.previousLines.length - newLines.length;
             for (let i = newLines.length; i < this.previousLines.length; i++) {
-                buffer += "\r\n\x1b[2K";
+                output.append("\r\n\x1b[2K");
             }
             // Move cursor back to end of new content
-            buffer += `\x1b[${extraLines}A`;
+            output.append(`\x1b[${extraLines}A`);
         }
-        buffer += "\x1b[?2026l"; // End synchronized output
+        output.append("\x1b[?2026l"); // End synchronized output
         if (process.env.PI_TUI_DEBUG === "1") {
             const debugDir = "/tmp/tui";
             fs.mkdirSync(debugDir, { recursive: true });
@@ -473,12 +534,11 @@ export class TuiMainScreen extends TuiBase {
                 JSON.stringify(this.previousLines, null, 2),
                 "",
                 "=== buffer ===",
-                JSON.stringify(buffer),
+                `[${output.length} chars written in bounded chunks]`,
             ].join("\n");
             fs.writeFileSync(debugPath, debugData);
         }
-        // Write entire buffer at once
-        this.terminal.write(buffer);
+        output.flush();
         // Track cursor position for next render
         // cursorRow tracks end of content (for viewport calculation)
         // hardwareCursorRow tracks actual terminal cursor position (for movement)

package/node_modules/@earendil-works/pi-tui/dist/tui.js

@@ -401,6 +401,10 @@ export class TuiBase extends Container {
     hasOverlay() {
         return this.overlayStack.some((o) => this.isOverlayVisible(o));
     }
+    /** Check if the focused component is a visible overlay */
+    isOverlayFocused() {
+        return this.overlayStack.some((entry) => entry.component === this.focusedComponent && this.isOverlayVisible(entry));
+    }
     /** Check if an overlay entry is currently visible */
     isOverlayVisible(entry) {
         if (entry.hidden)

package/node_modules/@earendil-works/pi-tui/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-tui",
-	"version": "0.84.1",
+	"version": "0.84.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",

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

@@ -1,4 +1,4 @@
-const { getSmithyContext } = require("@smithy/core/transport");
+const { getSmithyContext, hasOwn } = require("@smithy/core/transport");
 exports.getSmithyContext = getSmithyContext;
 const { HttpRequest } = require("@smithy/core/protocols");
 const { requestBuilder } = require("@smithy/core/protocols");
@@ -203,6 +203,8 @@ class DefaultIdentityProviderConfig {
     authSchemes = new Map();
     constructor(config) {
         for (const key in config) {
+            if (!hasOwn(config, key))
+                continue;
             const value = config[key];
             if (value !== undefined) {
                 this.authSchemes.set(key, value);

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

@@ -1,7 +1,7 @@
 const { nv, NumericValue, calculateBodyLength, generateIdempotencyToken, fromBase64, _parseEpochTimestamp } = require("@smithy/core/serde");
+const { hasOwn, getSmithyContext } = require("@smithy/core/transport");
 const { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require("@smithy/core/protocols");
 const { NormalizedSchema, deref, TypeRegistry } = require("@smithy/core/schema");
-const { getSmithyContext } = require("@smithy/core/transport");
 
 const majorUint64 = 0;
 const majorNegativeInt64 = 1;
@@ -299,23 +299,39 @@ function decodeTagValue(at, to, minor, unsignedInt, offset) {
     }
     else if (minor === 4) {
         const decimalFraction = decode(at + offset, to);
-        const [exponent, mantissa] = decimalFraction;
+        const [rawExponent, mantissa] = decimalFraction;
         const normalizer = mantissa < 0 ? -1 : 1;
-        const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
-        let numericString;
+        const absMantissa = BigInt(normalizer) * BigInt(mantissa);
+        const mantissaDigits = String(absMantissa);
         const sign = mantissa < 0 ? "-" : "";
-        numericString =
-            exponent === 0
-                ? mantissaStr
-                : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-        numericString = numericString.replace(/^0+/g, "");
-        if (numericString === "") {
-            numericString = "0";
-        }
-        if (numericString[0] === ".") {
-            numericString = "0" + numericString;
-        }
-        numericString = sign + numericString;
+        let numericString;
+        const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
+        if (isSmallExponent) {
+            const exponent = rawExponent;
+            const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
+            numericString =
+                exponent === 0
+                    ? mantissaStr
+                    : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
+            numericString = numericString.replace(/^0+/g, "");
+            if (numericString === "") {
+                numericString = "0";
+            }
+            if (numericString[0] === ".") {
+                numericString = "0" + numericString;
+            }
+            numericString = sign + numericString;
+        }
+        else {
+            const bigExponent = BigInt(rawExponent);
+            if (mantissaDigits.length === 1) {
+                numericString = sign + mantissaDigits + "e" + String(bigExponent);
+            }
+            else {
+                const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
+                numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
+            }
+        }
         _offset = offset + _offset;
         return nv(numericString);
     }
@@ -664,13 +680,21 @@ function encode(_input) {
         }
         else if (typeof input === "object") {
             if (input instanceof NumericValue) {
-                const decimalIndex = input.string.indexOf(".");
-                const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
-                const mantissa = BigInt(input.string.replace(".", ""));
+                let str = input.string;
+                let expOffset = BigInt(0);
+                const eIndex = str.search(/[eE]/);
+                if (eIndex !== -1) {
+                    expOffset = BigInt(str.slice(eIndex + 1));
+                    str = str.slice(0, eIndex);
+                }
+                const decimalIndex = str.indexOf(".");
+                const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+                const exponent = expOffset - BigInt(fractionDigits);
+                const mantissa = BigInt(str.replace(".", ""));
                 data[cursor$1++] = 0b110_00100;
                 encodeInteger(majorList, 2);
                 encodeStack.push(mantissa);
-                encodeStack.push(exponent);
+                encodeStack.push(exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn ? Number(exponent) : exponent);
                 continue;
             }
             if (input[tagSymbol]) {
@@ -888,6 +912,8 @@ const loadSmithyRpcV2CborErrorCode = (output, data) => {
     }
     let codeKey;
     for (const key in data) {
+        if (!hasOwn(data, key))
+            continue;
         if (key.toLowerCase() === "code") {
             codeKey = key;
             break;
@@ -920,6 +946,8 @@ const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, bod
     }
     if (endpoint.headers) {
         for (const name in endpoint.headers) {
+            if (!hasOwn(endpoint.headers, name))
+                continue;
             contents.headers[name] = endpoint.headers[name];
         }
     }
@@ -1180,6 +1208,8 @@ function writeStruct(ns, value, serdeContext) {
     }
     if (typeof value.__type === "string") {
         for (const k in value) {
+            if (!hasOwn(value, k))
+                continue;
             if (!memberNames.includes(k)) {
                 writeString(k);
                 writeUntypedValue(value[k]);
@@ -1245,6 +1275,8 @@ function writeMap(ns, value, isDocument, serdeContext) {
     const valueSchema = ns.getValueSchema();
     const keys = [];
     for (const k in value) {
+        if (!hasOwn(value, k))
+            continue;
         const v = value[k];
         if (isDocument ? v !== undefined : v != null || sparse) {
             keys.push(k);
@@ -1506,14 +1538,27 @@ function writeTag(tagValue, innerValue) {
     writeUntypedValue(innerValue);
 }
 function writeNumericValue(nv) {
-    const decimalIndex = nv.string.indexOf(".");
-    const exponent = decimalIndex === -1 ? 0 : decimalIndex - nv.string.length + 1;
-    const mantissa = BigInt(nv.string.replace(".", ""));
+    let str = nv.string;
+    let expOffset = BigInt(0);
+    const eIndex = str.search(/[eE]/);
+    if (eIndex !== -1) {
+        expOffset = BigInt(str.slice(eIndex + 1));
+        str = str.slice(0, eIndex);
+    }
+    const decimalIndex = str.indexOf(".");
+    const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+    const exponent = expOffset - BigInt(fractionDigits);
+    const mantissa = BigInt(str.replace(".", ""));
     ensure(9);
     buf[cursor++] = 0b110_00100;
     encodeHeader(majorList, 2);
     ensure(9);
-    writeInteger(exponent);
+    if (exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn) {
+        writeInteger(Number(exponent));
+    }
+    else {
+        writeBigInt(exponent);
+    }
     writeBigInt(mantissa);
 }
 function writeTimestamp(date) {
@@ -1645,6 +1690,8 @@ function readStruct(ns, count, startPos) {
     if (isUnion) {
         let resultEmpty = true;
         for (const _ in result) {
+            if (!hasOwn(result, _))
+                continue;
             resultEmpty = false;
             break;
         }
@@ -1684,23 +1731,39 @@ function readTag(ns) {
     if (tagNumber === 4) {
         const docSchema = NormalizedSchema.of(15);
         const pair = readValue(docSchema);
-        const [exponent, mantissa] = pair;
+        const [rawExponent, mantissa] = pair;
         const normalizer = mantissa < 0 ? -1 : 1;
-        const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
-        let numericString;
+        const absMantissa = BigInt(normalizer) * BigInt(mantissa);
+        const mantissaDigits = String(absMantissa);
         const sign = mantissa < 0 ? "-" : "";
-        numericString =
-            exponent === 0
-                ? mantissaStr
-                : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-        numericString = numericString.replace(/^0+/g, "");
-        if (numericString === "") {
-            numericString = "0";
-        }
-        if (numericString[0] === ".") {
-            numericString = "0" + numericString;
-        }
-        numericString = sign + numericString;
+        let numericString;
+        const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
+        if (isSmallExponent) {
+            const exponent = rawExponent;
+            const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
+            numericString =
+                exponent === 0
+                    ? mantissaStr
+                    : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
+            numericString = numericString.replace(/^0+/g, "");
+            if (numericString === "") {
+                numericString = "0";
+            }
+            if (numericString[0] === ".") {
+                numericString = "0" + numericString;
+            }
+            numericString = sign + numericString;
+        }
+        else {
+            const bigExponent = BigInt(rawExponent);
+            if (mantissaDigits.length === 1) {
+                numericString = sign + mantissaDigits + "e" + String(bigExponent);
+            }
+            else {
+                const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
+                numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
+            }
+        }
         return nv(numericString);
     }
     const docSchema = NormalizedSchema.of(15);
@@ -1797,6 +1860,8 @@ function readMapIndefinite(ns) {
                 if (isUnion) {
                     let resultEmpty = true;
                     for (const _ in result) {
+                        if (!hasOwn(result, _))
+                            continue;
                         resultEmpty = false;
                         break;
                     }
@@ -2101,6 +2166,8 @@ function transformObject(ns, value) {
     if (ns.isMapSchema()) {
         const targetSchema = ns.getValueSchema();
         for (const key in value) {
+            if (!hasOwn(value, key))
+                continue;
             newObject[key] = transformObject(targetSchema, value[key]);
         }
     }
@@ -2110,6 +2177,8 @@ function transformObject(ns, value) {
         if (isUnion) {
             keys = new Set();
             for (const k in value) {
+                if (!hasOwn(value, k))
+                    continue;
                 if (k !== "__type") {
                     keys.add(k);
                 }
@@ -2126,6 +2195,8 @@ function transformObject(ns, value) {
         if (isUnion && keys?.size === 1) {
             let newObjectEmpty = true;
             for (const _ in newObject) {
+                if (!hasOwn(newObject, _))
+                    continue;
                 newObjectEmpty = false;
                 break;
             }
@@ -2136,6 +2207,8 @@ function transformObject(ns, value) {
         }
         else if (typeof value.__type === "string") {
             for (const k in value) {
+                if (!hasOwn(value, k))
+                    continue;
                 if (!(k in newObject)) {
                     newObject[k] = value[k];
                 }
@@ -2298,6 +2371,8 @@ class CborShapeSerializer extends SerdeContext {
             if (ns.isMapSchema()) {
                 const sparse = !!ns.getMergedTraits().sparse;
                 for (const key in sourceObject) {
+                    if (!hasOwn(sourceObject, key))
+                        continue;
                     const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
                     if (value != null || sparse) {
                         newObject[key] = value;
@@ -2318,6 +2393,8 @@ class CborShapeSerializer extends SerdeContext {
                 }
                 else if (typeof sourceObject.__type === "string") {
                     for (const k in sourceObject) {
+                        if (!hasOwn(sourceObject, k))
+                            continue;
                         if (!(k in newObject)) {
                             newObject[k] = this.serialize(15, sourceObject[k]);
                         }
@@ -2334,6 +2411,8 @@ class CborShapeSerializer extends SerdeContext {
                     return newArray;
                 }
                 for (const key in sourceObject) {
+                    if (!hasOwn(sourceObject, key))
+                        continue;
                     newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
                 }
             }
@@ -2408,6 +2487,8 @@ class CborShapeDeserializer extends SerdeContext {
             if (ns.isMapSchema()) {
                 const targetSchema = ns.getValueSchema();
                 for (const key in value) {
+                    if (!hasOwn(value, key))
+                        continue;
                     const itemValue = this.readValue(targetSchema, value[key]);
                     newObject[key] = itemValue;
                 }
@@ -2418,6 +2499,8 @@ class CborShapeDeserializer extends SerdeContext {
                 if (isUnion) {
                     keys = new Set();
                     for (const k in value) {
+                        if (!hasOwn(value, k))
+                            continue;
                         if (k !== "__type") {
                             keys.add(k);
                         }
@@ -2434,6 +2517,8 @@ class CborShapeDeserializer extends SerdeContext {
                 if (isUnion && keys?.size === 1) {
                     let newObjectEmpty = true;
                     for (const _ in newObject) {
+                        if (!hasOwn(newObject, _))
+                            continue;
                         newObjectEmpty = false;
                         break;
                     }
@@ -2444,6 +2529,8 @@ class CborShapeDeserializer extends SerdeContext {
                 }
                 else if (typeof value.__type === "string") {
                     for (const k in value) {
+                        if (!hasOwn(value, k))
+                            continue;
                         if (!(k in newObject)) {
                             newObject[k] = value[k];
                         }