msgpackr 1.11.13 → 1.12.0

package/dist/test.js

@@ -1357,7 +1357,13 @@
 					hasSharedUpdate = false;
 				let encodingError;
 				try {
-					if (packr.randomAccessStructure && value && typeof value === 'object') {
+					// readOnlyStructures: skip the random-access struct write path so NO new struct is
+					// minted. randomAccessStructure stays true (the struct READ path and the struct-safe
+					// integer boundary are preserved, so existing struct data still decodes), but objects
+					// fall through to the normal pack()->writeObject->writeRecord path and are written as
+					// classic shared-structure records (byte range 0x40-0x7f, disjoint from struct headers
+					// at 0x20-0x3f) — the bounded, width-agnostic encoding used before struct mode.
+					if (packr.randomAccessStructure && !packr.readOnlyStructures && value && typeof value === 'object') {
 						if (value.constructor === Object) writeStruct(value); // simple object
 						else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some(extClass => value instanceof extClass)) {
 							// allow user classes, if they don't need special handling (but do use toJSON if available)
@@ -1423,7 +1429,14 @@
 							let newSharedData = prepareStructures$1(structures, packr);
 							if (!encodingError) { // TODO: If there is an encoding error, should make the structures as uninitialized so they get rebuilt next time
 								if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
-									// get updated structures and try again if the update failed
+									// The save was declined (a concurrent writer updated the shared structures,
+									// or the store transaction did not durably commit). Our in-memory
+									// structures + transition trie may now reference record ids that were
+									// never persisted; re-packing as-is would re-emit the same record pointing
+									// at an unpersisted structure (-> "Record id is not defined" on decode).
+									// Mark structures uninitialized so the re-pack reloads durable structures
+									// via getStructures, rebuilds the transition trie, and re-mints + re-saves.
+									structures.uninitialized = true;
 									return packr.pack(value, encodeOptions)
 								}
 								packr.lastNamedStructuresLength = sharedLength;
@@ -4219,6 +4232,31 @@
 			assert.deepEqual(inputData, outputData);
 		});
 
+		test('declined structure save re-packs against durable structures (no dangling record)', function() {
+			// Regression: when saveStructures declines a save (a concurrent writer updated the shared
+			// structures, or the store txn did not durably commit), the in-memory structures/transition
+			// trie reference a record id that was never persisted. The re-pack must reload the durable
+			// structures and re-mint/re-save — otherwise it re-emits the same record pointing at an
+			// unsaved structure, and reads throw "Record id is not defined".
+			const meta = new Packr();
+			let store = null;
+			let declinedOnce = false;
+			const packr = new Packr({
+				useRecords: true,
+				getStructures() { return store ? meta.unpack(store) : undefined },
+				saveStructures(structures) {
+					if (!declinedOnce) { declinedOnce = true; return false } // decline the first save
+					store = meta.pack(structures); return true
+				},
+			});
+			const a = packr.pack({ x: 9, y: 8 });  // first mint is declined -> must re-pack + re-save
+			const b = packr.pack({ x: 7, y: 6 });  // same shape -> must still reference a saved structure
+			// A fresh reader sees only the durably-saved structures (another thread / post-restart):
+			const reader = new Packr({ getStructures() { return store ? meta.unpack(store) : undefined } });
+			assert.deepEqual(reader.unpack(a), { x: 9, y: 8 });
+			assert.deepEqual(reader.unpack(b), { x: 7, y: 6 });
+		});
+
 		test('big buffer', function() {
 			var size = 100000000;
 			var data = new Uint8Array(size).fill(1);
@@ -4817,5 +4855,74 @@
 		});
 	});
 
+	suite('msgpackr – readOnlyStructures (write-disable, read-compatible)', function () {
+		// readOnlyStructures keeps randomAccessStructure decode semantics — existing random-access
+		// struct data still decodes and the struct-safe integer boundary is preserved — but never mints
+		// a new random-access structure on write. Objects fall through to the classic shared-structure
+		// record path (bytes 0x40-0x7f, disjoint from struct headers at 0x20-0x3f), the bounded,
+		// width-agnostic encoding used before struct mode. This is the mechanism for disabling typed
+		// structures on an existing store without breaking reads.
+		const sharedStore = () => {
+			let saved;
+			return { getStructures: () => saved, saveStructures: (s) => { saved = s; return true; } };
+		};
+
+		test('decodes pre-existing random-access structs (read stays enabled)', function () {
+			const full = new Packr({ randomAccessStructure: true, useRecords: true });
+			const rec = { a: 1, b: 'hello', c: true, n: 42 };
+			const buf = full.pack(rec);
+			assert.ok(buf[0] >= 0x20 && buf[0] < 0x40, 'control: full encoder emits a random-access struct');
+
+			const ro = new Packr({ randomAccessStructure: true, useRecords: true, readOnlyStructures: true });
+			ro.typedStructs = full.typedStructs; // share the existing random-access dictionary
+			assert.deepEqual(ro.unpack(buf), rec);
+		});
+
+		test('writes classic shared-structure records (0x40-0x7f), never a random-access struct', function () {
+			const ro = new Packr({ randomAccessStructure: true, useRecords: true, readOnlyStructures: true, ...sharedStore() });
+			const rec = { x: 9, y: 'world', z: [1, 2, 3], nested: { deep: 50, k: 42 } };
+			const b1 = ro.pack(rec);
+			assert.ok(b1[0] >= 0x40 && b1[0] < 0x80, 'expected a classic record (0x40-0x7f), got 0x' + b1[0].toString(16));
+			assert.strictEqual(ro.typedStructs ? ro.typedStructs.length : 0, 0, 'no random-access struct minted');
+			assert.deepEqual(ro.unpack(b1), rec);
+			// a second record of the same shape reuses the shared classic structure (still classic)
+			const b2 = ro.pack({ x: 1, y: 'a', z: [], nested: { deep: 0, k: 0 } });
+			assert.ok(b2[0] >= 0x40 && b2[0] < 0x80, 'second record also classic');
+		});
+
+		test('preserves the struct-safe integer boundary (nested 0x20-0x3f ints do not collide)', function () {
+			const ro = new Packr({ randomAccessStructure: true, useRecords: true, readOnlyStructures: true, ...sharedStore() });
+			for (const v of [0x1f, 0x20, 0x2a, 0x3f, 0x40, 0x7f]) {
+				assert.deepEqual(ro.unpack(ro.pack({ v, nested: { w: v } })), { v, nested: { w: v } });
+			}
+		});
+
+		test('a normal randomAccessStructure reader decodes readOnly classic records (replication compat)', function () {
+			let saved;
+			const store = { getStructures: () => saved, saveStructures: (s) => { saved = s; return true; } };
+			const ro = new Packr({ randomAccessStructure: true, useRecords: true, readOnlyStructures: true, ...store });
+			const roBuf = ro.pack({ p: 'q', n: 42 });
+			assert.ok(roBuf[0] >= 0x40 && roBuf[0] < 0x80, 'readOnly writes a classic record');
+
+			// A peer that is NOT readOnly (a normal struct-writing node) shares the classic-structure
+			// store and decodes the classic record correctly — no mapsAsObjects needed, since classic
+			// records decode to objects natively.
+			const peer = new Packr({ randomAccessStructure: true, useRecords: true, ...store });
+			assert.deepEqual(peer.unpack(roBuf), { p: 'q', n: 42 });
+		});
+
+		test('every object shape uses the classic path (null-proto, shadowed ctor) — no random-access struct', function () {
+			const ro = new Packr({ randomAccessStructure: true, useRecords: true, readOnlyStructures: true, ...sharedStore() });
+
+			const np = Object.create(null); np.a = 1; np.b = 'x';
+			assert.deepEqual(ro.unpack(ro.pack(np)), { a: 1, b: 'x' });
+
+			const cs = { constructor: 'shadow', a: 1 };
+			assert.deepEqual(ro.unpack(ro.pack(cs)), { constructor: 'shadow', a: 1 });
+
+			assert.strictEqual(ro.typedStructs ? ro.typedStructs.length : 0, 0, 'no random-access struct minted for any shape');
+		});
+	});
+
 })(chai, null, module, fs);
 //# sourceMappingURL=test.js.map