rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptStaticAnalysisCalls.js

@@ -32,6 +32,8 @@ export const inspectCall = (source, node, context) => {
         addReference(context, { node, kind: "service-worker", specifier: first });
     inspectEndpointCall(node, name, first, context);
     inspectStorageCall(node, name, first, context);
+    if (first === "audio" || first === "video")
+        noteMediaElementPreloads(node, accumulator);
     if (name.endsWith("loadFile") && first !== undefined)
         addLocatedFinding(context, {
             collection: accumulator.roles,
@@ -61,6 +63,18 @@ export const inspectCall = (source, node, context) => {
             },
         });
 };
+// Element factories such as jsx("audio", props) and createElement("video",
+// props) carry the HTML media `preload` hint ("none", "metadata", "auto"),
+// which never names an Electron preload script.
+const noteMediaElementPreloads = (node, accumulator) => {
+    const props = node.arguments[1];
+    if (!t.isObjectExpression(props))
+        return;
+    for (const property of props.properties)
+        if (t.isObjectProperty(property) &&
+            semanticStaticPropertyName(property.key, property.computed) === "preload")
+            accumulator.mediaElementPreloads.add(property);
+};
 const requireCallSpecifier = (node, name, moduleRequireName) => {
     if (name === "require" || name.endsWith(".require"))
         return { specifier: argumentValue(node.arguments[0]) };
@@ -114,6 +128,12 @@ const inspectEndpointCall = (node, name, first, context) => {
             mechanism: `call:${name}`,
         });
 };
+/** Record tRPC procedures, tRPC link URLs and named GraphQL operations. */
+export const inspectRpcNode = (node, context) => {
+    const rpc = context.rpcScan.inspect(node);
+    if (rpc !== undefined)
+        addEndpoint(context, { node, kind: "network", ...rpc });
+};
 export const inspectRouteProperty = (node, context) => {
     const key = semanticStaticPropertyName(node.key, node.computed);
     if ((key === "path" || key === "route") && t.isStringLiteral(node.value))
@@ -127,6 +147,8 @@ export const inspectRouteProperty = (node, context) => {
 export const inspectRoleProperty = (node, context) => {
     if (semanticStaticPropertyName(node.key, node.computed) !== "preload")
         return;
+    if (context.accumulator.mediaElementPreloads.has(node))
+        return;
     const path = staticPath(node.value);
     if (path === undefined)
         return;
@@ -213,13 +235,35 @@ export const addSourceMapDirectives = (source, comments, accumulator) => {
             end === undefined ||
             end === null)
             continue;
-        const match = /^(?:\/\/|\/\*)[#@]\s*sourceMappingURL\s*=\s*([^\s*]+)/u.exec(source.slice(start, end));
-        if (match === null)
+        const commentSource = source.slice(start, end);
+        if (!(commentSource.startsWith("//") || commentSource.startsWith("/*")) ||
+            !(commentSource[2] === "#" || commentSource[2] === "@"))
+            continue;
+        // Single-class searches avoid regex backtracking over unbounded whitespace
+        // or inline URLs, which can exhaust the engine stack on two-byte strings.
+        const nameOffset = commentSource.slice(3).search(/\S/u);
+        if (nameOffset === -1)
+            continue;
+        const nameStart = 3 + nameOffset;
+        if (!commentSource.startsWith("sourceMappingURL", nameStart))
+            continue;
+        const nameEnd = nameStart + "sourceMappingURL".length;
+        const equalsOffset = commentSource.slice(nameEnd).search(/\S/u);
+        if (equalsOffset === -1)
+            continue;
+        const equalsStart = nameEnd + equalsOffset;
+        if (!commentSource.startsWith("=", equalsStart))
+            continue;
+        const urlOffset = commentSource.slice(equalsStart + 1).search(/\S/u);
+        if (urlOffset === -1)
             continue;
-        const declared = match[1];
-        if (declared === undefined || declared.length === 0)
+        const declaredStart = equalsStart + 1 + urlOffset;
+        const terminator = commentSource.slice(declaredStart).search(/[\s*]/u);
+        const declaredEnd = terminator === -1 ? commentSource.length : declaredStart + terminator;
+        if (declaredEnd === declaredStart)
             continue;
-        const location = rangeForOffsets(source, start, start + match[0].length);
+        const declared = commentSource.slice(declaredStart, declaredEnd);
+        const location = rangeForOffsets(source, start, start + declaredEnd);
         addFindingOnce(accumulator, `source-map\0${declared}`, () => accumulator.sourceMaps.push({ declared_url: declared, location }));
     }
 };

package/dist/domain/javascript/javascriptStaticAnalysisFindings.js

@@ -76,7 +76,11 @@ export const addFindingOnce = (accumulator, key, add) => {
     add();
 };
 /** Attach recovered bundle-module ownership to findings after traversal. */
-export const finalizeLocatedFindings = (values, modules) => values.map(({ offset, value }) => ({
-    ...value,
-    module_key: modules.find(offset)?.key ?? null,
-}));
+export const finalizeLocatedFindings = (values, modules) => values.map(({ offset, value }) => {
+    const module = modules.find(offset);
+    return {
+        ...value,
+        module_key: module?.key ?? null,
+        ...(module === undefined ? {} : { module_runtime: module.runtime }),
+    };
+});

package/dist/domain/javascript/javascriptStaticAnalysisHelpers.js

@@ -2,8 +2,8 @@ import { createHash } from "node:crypto";
 import { posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as t from "@babel/types";
-import { readExactJavaScriptLiteral, semanticStaticPropertyName, } from "./javascriptAstValues.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 /** Explicit result for source text that Babel cannot parse. */
 export const failedJavaScriptStaticAnalysis = () => ({
     parse_status: "failed",
@@ -67,8 +67,9 @@ const findChunkRuntime = (node) => {
             pending.push(current.right, current.left);
             continue;
         }
-        if (t.isParenthesizedExpression(current) || t.isTSAsExpression(current))
-            pending.push(current.expression);
+        const unwrapped = unwrapJavaScriptExpression(current).node;
+        if (unwrapped !== current)
+            pending.push(unwrapped);
     }
     return undefined;
 };
@@ -102,26 +103,25 @@ export const staticArrayValues = (array) => {
         const value = argumentValue(element);
         return value === undefined ? [] : [value];
     });
-    const values = [...new Set(staticValues)].sort(compareCodePoints);
+    const values = [...new Set(staticValues)].sort(compareUnicodeCodePoints);
     return {
         values,
         unknown: array.elements.length - staticValues.length,
     };
 };
-/** Resolve a path composed only from inert literal syntax. */
-export const staticPath = (node) => staticPathAt(node);
 /** Classify whether inert path syntax is a module specifier or file expression. */
 export const staticPathResolutionContext = (node) => isFilesystemPathExpression(node)
     ? "filesystem-expression"
     : "module-specifier";
-const staticPathAt = (node) => {
+/** Resolve a path composed only from inert literal syntax. */
+export const staticPath = (node) => {
     if (t.isStringLiteral(node))
         return node.value;
     if (t.isTemplateLiteral(node) && node.expressions.length === 0)
         return stringValue(node);
     if (t.isBinaryExpression(node, { operator: "+" })) {
-        const left = staticPathAt(node.left);
-        const right = staticPathAt(node.right);
+        const left = staticPath(node.left);
+        const right = staticPath(node.right);
         return left === undefined || right === undefined
             ? undefined
             : `${left}${right}`;
@@ -152,7 +152,7 @@ const staticCallPath = (node) => {
     for (const argument of node.arguments) {
         if (isDirectoryIdentity(argumentNode(argument)))
             continue;
-        const value = t.isNode(argument) ? staticPathAt(argument) : undefined;
+        const value = t.isNode(argument) ? staticPath(argument) : undefined;
         if (value === undefined)
             return undefined;
         parts.push(value);
@@ -164,7 +164,7 @@ const staticFileUrlPath = (argument) => {
         return undefined;
     return isSourceFileUrl(argument)
         ? sourceRelativeFileUrlPath(argument)
-        : staticPathAt(argument);
+        : staticPath(argument);
 };
 /** Project a known source-relative URL through the actual file URL decoder. */
 const sourceRelativeFileUrlPath = (node) => {
@@ -213,7 +213,7 @@ const staticResolvedPath = (node) => {
             parts.push(null);
             continue;
         }
-        const value = t.isNode(argument) ? staticPathAt(argument) : undefined;
+        const value = t.isNode(argument) ? staticPath(argument) : undefined;
         // Validate every argument, including those before the last anchor.
         if (value === undefined)
             return undefined;
@@ -521,9 +521,20 @@ const pointForOffset = (source, offset) => {
 /** Observe known bundler/framework marker strings without claiming dependency use. */
 export const detectVendors = (source) => vendorPatterns.flatMap(({ name, patterns }) => patterns.some((pattern) => source.includes(pattern)) ? [name] : []);
 /** Commit the static semantic content used to deduplicate registrations. */
-export const registrationKey = (registration) => `${registration.runtime}\0${registration.chunk_keys.join("\0")}\0${String(registration.unknown_chunk_keys)}\0${registration.modules.map(({ module_key: key, source_sha256: digest }) => `${key}:${digest}`).join("\0")}`;
+export const registrationKey = (registration) => 
+// Collision-free tuple: chunk/module keys are variable-length source-derived
+// lists, so NUL-joins would collapse ["a\0b"] with ["a", "b"].
+compositeKey([
+    registration.runtime,
+    registration.chunk_keys,
+    String(registration.unknown_chunk_keys),
+    registration.modules.map(({ module_key: key, source_sha256: digest }) => [
+        key,
+        digest,
+    ]),
+]);
 /** Sort values by a deterministic unique semantic key. */
-export const sortedUnique = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareCodePoints(key(left), key(right)));
+export const sortedUnique = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareUnicodeCodePoints(key(left), key(right)));
 /** Hash exact UTF-8 source text. */
 export const sha256Text = (value) => createHash("sha256").update(value).digest("hex");
 /** Recognized route-construction call suffixes. */

package/dist/domain/javascript/javascriptStaticAnalysisState.js

@@ -14,6 +14,7 @@ export const createJavaScriptAnalysisAccumulator = (sourceLength) => ({
     utilityProcesses: [],
     nativeAddonBindings: [],
     moduleRangeIndex: new JavaScriptModuleRangeIndex(sourceLength),
+    mediaElementPreloads: new WeakSet(),
     seen: new Set(),
     visitedNodes: 0,
     unknownFindings: 0,

package/dist/domain/javascript/sourceToBundleComparison.js

@@ -1,5 +1,7 @@
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
-import { absenceClaimable, canonicalDigest } from "../comparisonSemantics.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { absenceClaimable } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, sourceToBundleComparisonResultSchema, } from "./sourceToBundleComparisonSchemas.js";
 import { buildSourceToBundleCandidateIndex, candidateHasDigest, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
 /** Compare historical source files to static source-bearing application nodes. */
@@ -33,7 +35,7 @@ export const compareSourceToBundle = (input) => {
     };
     return sourceToBundleComparisonResultSchema.parse({
         ...semanticResult,
-        comparison_id: `stbc_${canonicalDigest(semanticResult, "Source-to-bundle comparison")}`,
+        comparison_id: `stbc_${digestCanonicalValue(semanticResult, "Source-to-bundle comparison")}`,
     });
 };
 const projectComparison = (input) => {
@@ -218,7 +220,7 @@ const markMergedMappings = (input, items) => {
         return { ...semantic, mapping_id: mappingId(input, semantic) };
     });
 };
-const mappingId = (input, item) => `stbc_item_${canonicalDigest({
+const mappingId = (input, item) => `stbc_item_${digestCanonicalValue({
     reference_root_sha256: input.reference.root_sha256,
     application_graph_id: input.application.graph.graph_id,
     ...item,
@@ -256,4 +258,4 @@ const comparisonLimitations = (factors) => uniqueSorted([
 ]);
 const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
 const compareCandidates = (left, right) => right.score - left.score ||
-    compareCodePoints(left.current_node_id, right.current_node_id);
+    compareUnicodeCodePoints(left.current_node_id, right.current_node_id);

package/dist/domain/javascript/sourceToBundleSignals.js

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, } from "./sourceToBundleComparisonSchemas.js";
 import { isDigest } from "../digests.js";
 const RELEVANT_NODE_KINDS = new Set([
@@ -24,11 +24,11 @@ const signalWeight = (kind) => {
 /** Keep source-bearing application nodes in stable identifier order. */
 export const sourceBearingNodes = (nodes) => nodes
     .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
-    .sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+    .sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));
 /** Keep historical source files in stable path order. */
 export const historicalSourceFiles = (graph) => graph.entries
     .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
-    .sort((left, right) => compareCodePoints(left.path, right.path));
+    .sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
 /** Build deterministic candidate indices without assigning fuzzy matches. */
 export const buildSourceToBundleCandidateIndex = (nodes) => {
     const projections = nodes.map(projectCurrentNode);
@@ -65,7 +65,7 @@ export const candidateIdsForSource = (source, index) => {
     for (const group of groups) {
         if (group === undefined)
             continue;
-        for (const nodeId of [...group].sort(compareCodePoints)) {
+        for (const nodeId of [...group].sort(compareUnicodeCodePoints)) {
             if (seen.has(nodeId))
                 continue;
             seen.add(nodeId);
@@ -166,7 +166,7 @@ const signal = (kind, sourceValue, currentValues) => ({
     kind,
     weight: signalWeight(kind),
     source_value: sourceValue,
-    current_values: [...new Set(currentValues)].sort(compareCodePoints),
+    current_values: [...new Set(currentValues)].sort(compareUnicodeCodePoints),
 });
 const candidateConfidence = (signals) => {
     const kinds = new Set(signals.map(({ kind }) => kind));
@@ -216,10 +216,10 @@ const normalizeCurrentPath = (raw) => {
 };
 const uniquePaths = (paths) => [
     ...new Map(paths.map((path) => [
-        `${path.kind}\0${path.value}\0${String(path.allowSuffix)}`,
+        compositeKey([path.kind, path.value, String(path.allowSuffix)]),
         path,
     ])).values(),
-].sort((left, right) => compareCodePoints(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
+].sort((left, right) => compareUnicodeCodePoints(compositeKey([left.kind, left.value]), compositeKey([right.kind, right.value])));
 const pathSuffixes = (path) => {
     const parts = path.split("/");
     return parts.map((_, index) => parts.slice(index).join("/"));

package/dist/domain/jeb/jebAnalysis.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { localPathStringSchema } from "../localPath.js";
+/**
+ * Caller intent for JEB-backed inspection, independent of the engine build.
+ *
+ * JEB resolves paths on the host running the JEB client that serves MCP; REA
+ * never launches the engine or opens the target itself.
+ */
+export const jebInputSchemas = {
+    inspect_jeb_client: z.strictObject({}),
+    open_jeb_project: z.strictObject({
+        path: localPathStringSchema.describe("Artifact file or existing .jdb2 project database, resolved by the running JEB client"),
+    }),
+    list_jeb_units: z.strictObject({
+        filter: z
+            .string()
+            .optional()
+            .describe("Wildcard filter matched against unit paths; '*' allowed"),
+        parent_unit_path: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Restrict results to descendants of this unit path"),
+        index: z
+            .number()
+            .int()
+            .nonnegative()
+            .default(0)
+            .describe("Zero-based index of the first result to return"),
+        count: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(100)
+            .describe("Maximum results to return; the engine protocol caps pages at 100"),
+    }),
+    decompile_jeb_item: z.strictObject({
+        unit_path: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Target code unit; the engine's first code unit in the project when omitted"),
+        item_address: z
+            .string()
+            .min(1)
+            .describe("Type or method address within the unit, as listed by the engine"),
+        item_kind: z.enum(["type", "method"]).describe("Kind of item to decompile"),
+    }),
+};
+/** Validate operation and input together so their types remain correlated. */
+export const jebRequestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({
+        operation: z.literal("inspect_jeb_client"),
+        input: jebInputSchemas.inspect_jeb_client,
+    }),
+    z.strictObject({
+        operation: z.literal("open_jeb_project"),
+        input: jebInputSchemas.open_jeb_project,
+    }),
+    z.strictObject({
+        operation: z.literal("list_jeb_units"),
+        input: jebInputSchemas.list_jeb_units,
+    }),
+    z.strictObject({
+        operation: z.literal("decompile_jeb_item"),
+        input: jebInputSchemas.decompile_jeb_item,
+    }),
+]);
+const engine = z.strictObject({
+    name: z.string().min(1),
+    version: z.string().nullable(),
+    endpoint: z.string().min(1),
+    gui_client: z.boolean().nullable(),
+});
+const unit = z.strictObject({
+    unit_path: z.string(),
+    unit_type: z.string(),
+});
+/** Portable JEB observations with explicit identity and coverage limitations. */
+export const jebResultSchemas = {
+    inspect_jeb_client: z.strictObject({
+        engine,
+        startup_ts: z.number().int().nonnegative().nullable(),
+        message: z.string().nullable(),
+    }),
+    open_jeb_project: z.strictObject({
+        engine,
+        project_name: z.string().nullable(),
+        creation_datetime: z.string().nullable(),
+        input_files: z.array(z.strictObject({
+            file_name: z.string(),
+            file_size: z.number().int().nonnegative(),
+            contents_sha256_hash: z.string(),
+        })),
+        units: z.array(unit),
+    }),
+    list_jeb_units: z.strictObject({
+        engine,
+        filter: z.string().nullable(),
+        parent_unit_path: z.string().nullable(),
+        index: z.number().int().nonnegative(),
+        count: z.number().int().positive(),
+        units: z.array(unit),
+        coverage: z.enum(["complete", "partial"]),
+    }),
+    decompile_jeb_item: z.strictObject({
+        engine,
+        unit_path: z.string().nullable(),
+        item_address: z.string(),
+        item_kind: z.enum(["type", "method"]),
+        text: z.string(),
+    }),
+};

package/dist/domain/jsonSerialization.js

@@ -1,10 +1,10 @@
 /** Encode ordinary JSON as bounded string parts without a document-sized allocation. */
 export function* jsonParts(value, pretty = false) {
-    yield* encodeValue(value, pretty, 0, new Set(), false);
+    yield* encodeValue(value, pretty, false);
 }
 /** Encode validated JSON with canonical key ordering without allocating the whole document. */
 export function* canonicalJsonParts(value) {
-    yield* encodeValue(value, false, 0, new Set(), true);
+    yield* encodeValue(value, false, true);
 }
 /** Buffer JSON parts while preserving complete UTF-16 surrogate pairs. */
 export function* bufferedJsonParts(parts) {
@@ -41,69 +41,123 @@ function* encodeString(value) {
     }
     yield '"';
 }
-function* encodeValue(value, pretty, depth, ancestors, canonical) {
-    if (typeof value === "string") {
-        yield* encodeString(value);
-        return;
-    }
-    if (value === null || typeof value === "boolean") {
-        yield value === null ? "null" : String(value);
-        return;
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-        yield String(value);
-        return;
-    }
+/** Encoded text accumulated before it is yielded as one part. */
+const PART_CHARACTERS = 16 * 1024;
+const indentation = [];
+const indent = (depth) => (indentation[depth] ??= `\n${"  ".repeat(depth)}`);
+/** Encoded text of a scalar, or undefined for a container or a long string. */
+const scalarText = (value) => {
+    if (typeof value === "string")
+        return value.length <= 8192 ? JSON.stringify(value) : undefined;
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return String(value);
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+};
+const openContainer = (value, depth, ancestors, canonical) => {
     if (typeof value !== "object" || value === null)
         throw new TypeError("JSON output requires ordinary JSON values");
     if (ancestors.has(value))
         throw new TypeError("JSON output contains a circular reference");
-    if (!Array.isArray(value) &&
-        Object.prototype.toString.call(value) !== "[object Object]")
+    const array = Array.isArray(value);
+    if (!array && Object.prototype.toString.call(value) !== "[object Object]")
         throw new TypeError("JSON output requires ordinary JSON objects");
     ancestors.add(value);
-    try {
-        const array = Array.isArray(value);
-        const keys = array ? undefined : Object.keys(value);
-        if (canonical)
-            keys?.sort();
-        const count = array ? value.length : (keys?.length ?? 0);
-        let written = 0;
-        yield array ? "[" : "{";
-        for (let index = 0; index < count; index += 1) {
-            let item;
-            let key;
-            if (array) {
-                item = value[index];
+    const keys = array ? undefined : Object.keys(value);
+    if (canonical)
+        keys?.sort();
+    const count = array ? value.length : (keys?.length ?? 0);
+    return { value, array, keys, count, depth, index: 0, written: 0 };
+};
+/** The next written member of a container, skipping values JSON omits. */
+const nextMember = (frame) => {
+    while (frame.index < frame.count) {
+        const index = frame.index;
+        frame.index += 1;
+        if (frame.array)
+            return { key: undefined, item: Reflect.get(frame.value, index) };
+        const key = frame.keys?.[index];
+        if (key === undefined)
+            throw new TypeError("JSON object changed during serialization");
+        const item = Reflect.get(frame.value, key);
+        // Incur's filter can select inherited methods. Match native JSON's
+        // omission without eagerly reading the rest of a bounded result.
+        if (item !== undefined &&
+            typeof item !== "function" &&
+            typeof item !== "symbol")
+            return { key, item };
+    }
+    return undefined;
+};
+/**
+ * Encode iteratively into bounded parts. Recursive `yield*` delegation passed
+ * every token through one generator frame per nesting level, which dominated
+ * the cost of writing large nested results.
+ */
+function* encodeValue(root, pretty, canonical) {
+    const ancestors = new Set();
+    const stack = [];
+    let buffer = "";
+    let pending = root;
+    let hasPending = true;
+    while (true) {
+        if (hasPending) {
+            hasPending = false;
+            const text = scalarText(pending);
+            if (text !== undefined)
+                buffer += text;
+            else if (typeof pending === "string") {
+                // A long string is split into surrogate-safe parts of its own.
+                if (buffer !== "")
+                    yield buffer;
+                buffer = "";
+                yield* encodeString(pending);
             }
             else {
-                key = keys?.[index];
-                if (key === undefined)
-                    throw new TypeError("JSON object changed during serialization");
-                item = Reflect.get(value, key);
-                // Incur's filter can select inherited methods. Match native JSON's
-                // omission without eagerly reading the rest of a bounded result.
-                if (item === undefined ||
-                    typeof item === "function" ||
-                    typeof item === "symbol")
-                    continue;
+                const frame = openContainer(pending, stack.length, ancestors, canonical);
+                stack.push(frame);
+                buffer += frame.array ? "[" : "{";
             }
-            if (written > 0)
-                yield ",";
-            if (pretty)
-                yield `\n${"  ".repeat(depth + 1)}`;
-            if (key !== undefined) {
-                yield* encodeString(key);
-                yield pretty ? ": " : ":";
+        }
+        if (buffer.length >= PART_CHARACTERS) {
+            yield buffer;
+            buffer = "";
+        }
+        const frame = stack.at(-1);
+        if (frame === undefined)
+            break;
+        const member = nextMember(frame);
+        if (member === undefined) {
+            if (pretty && frame.written > 0)
+                buffer += indent(frame.depth);
+            buffer += frame.array ? "]" : "}";
+            ancestors.delete(frame.value);
+            stack.pop();
+            continue;
+        }
+        if (frame.written > 0)
+            buffer += ",";
+        if (pretty)
+            buffer += indent(frame.depth + 1);
+        if (member.key !== undefined) {
+            const key = scalarText(member.key);
+            if (key !== undefined)
+                buffer += key;
+            else {
+                if (buffer !== "")
+                    yield buffer;
+                buffer = "";
+                yield* encodeString(member.key);
             }
-            yield* encodeValue(item, pretty, depth + 1, ancestors, canonical);
-            written += 1;
+            buffer += pretty ? ": " : ":";
         }
-        if (pretty && written > 0)
-            yield `\n${"  ".repeat(depth)}`;
-        yield array ? "]" : "}";
-    }
-    finally {
-        ancestors.delete(value);
+        frame.written += 1;
+        pending = member.item;
+        hasPending = true;
     }
+    if (buffer !== "")
+        yield buffer;
 }