@adeu/core 1.12.1 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adeu/core",
-  "version": "1.12.1",
+  "version": "1.14.0",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/engine.bugs.test.ts

@@ -531,4 +531,24 @@ describe("Resolved Bugs Core Engine Verification", () => {
     const final_comment_parts = doc.pkg.parts.filter(p => p.contentType.includes("comments"));
     expect(final_comment_parts.length).toBe(0);
   });
+
+  it("Double-Serialization Core: process_batch successfully processes double-serialized JSON strings", async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "original text");
+    const engine = new RedlineEngine(doc);
+
+    // On unpatched code, this will throw a raw TypeError: Cannot create property '_applied_status' on string
+    // On patched code, it will successfully parse and apply the modify change
+    engine.process_batch([
+      JSON.stringify({
+        type: "modify",
+        target_text: "original text",
+        new_text: "updated text",
+      }),
+    ] as any);
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf, true);
+    expect(text).toContain("updated text");
+  });
 });

package/src/engine.ts

@@ -1399,6 +1399,34 @@ export class RedlineEngine {
     changes: DocumentChange[],
     dry_run: boolean = false,
   ): any {
+    // Defensive sanitization: some LLM clients "double-serialize" nested
+    // arrays, delivering each element of `changes` as a JSON string instead of
+    // a parsed object. Downstream code mutates state trackers (e.g.
+    // `edit._applied_status`) and reads `change.type` on these elements, which
+    // throws a TypeError on string primitives. Parse stringified elements back
+    // into objects here, leaving genuine objects (and unparseable strings)
+    // untouched so validation can surface a clear error rather than crashing.
+    if (Array.isArray(changes)) {
+      changes = changes.map((item: any) => {
+        if (typeof item === "string") {
+          try {
+            const parsed = JSON.parse(item);
+            // Only swap in the parsed value if it is an object; a string that
+            // parses to a scalar (e.g. "42") is not a valid change.
+            if (parsed !== null && typeof parsed === "object") {
+              return parsed;
+            }
+            return item;
+          } catch {
+            // Leave malformed strings as-is; the validation pass downstream
+            // will report them rather than crashing on a raw TypeError.
+            return item;
+          }
+        }
+        return item;
+      }) as DocumentChange[];
+    }
+
     if (dry_run) {
       const baselines = new Map<any, Element>();
       for (const part of this.doc.pkg.parts) {