@eik/core 2.1.83 → 2.2.1

package/CHANGELOG.md

@@ -1,37 +1,16 @@
-## [2.1.83](https://github.com/eik-lib/core/compare/v2.1.82...v2.1.83) (2026-08-19)
+## [2.2.1](https://github.com/eik-lib/core/compare/v2.2.0...v2.2.1) (2026-08-20)
 
 
 ### Bug Fixes
 
-* reduce MAX_CONCURRENT_WRITES from 16 to 8 ([#642](https://github.com/eik-lib/core/issues/642)) ([8ab90c6](https://github.com/eik-lib/core/commit/8ab90c62123ac0d2001d8e0dff5ae4d21a194531))
+* **deps:** update eik packages ([#644](https://github.com/eik-lib/core/issues/644)) ([b94cddb](https://github.com/eik-lib/core/commit/b94cddb8aef95066769212a48ac51f0da86bac4f))
 
-## [2.1.82](https://github.com/eik-lib/core/compare/v2.1.81...v2.1.82) (2026-08-19)
+# [2.2.0](https://github.com/eik-lib/core/compare/v2.1.83...v2.2.0) (2026-08-20)
 
 
-### Bug Fixes
-
-* reclassify GCS 412 errors in writeJSONWithOptions rather than via stream re-emission ([#641](https://github.com/eik-lib/core/issues/641)) ([5094866](https://github.com/eik-lib/core/commit/5094866a9f47cfd75a3252e3b9d160df6bfc442b))
-
-## [2.1.81](https://github.com/eik-lib/core/compare/v2.1.80...v2.1.81) (2026-08-19)
-
-
-### Bug Fixes
-
-* **deps:** update eik packages to v2.1.0 ([#640](https://github.com/eik-lib/core/issues/640)) ([4ee2d69](https://github.com/eik-lib/core/commit/4ee2d69491e287f5a719973c3b20cf11f9c327ad))
-
-## [2.1.80](https://github.com/eik-lib/core/compare/v2.1.79...v2.1.80) (2026-08-19)
-
-
-### Bug Fixes
-
-* **deps:** update eik packages ([#639](https://github.com/eik-lib/core/issues/639)) ([4e0aa6c](https://github.com/eik-lib/core/commit/4e0aa6caf9630a79af03dd2889392d60cf8b276f))
-
-## [2.1.79](https://github.com/eik-lib/core/compare/v2.1.78...v2.1.79) (2026-08-19)
-
-
-### Bug Fixes
+### Features
 
-* use atomic sink writes to prevent concurrent upload races ([#638](https://github.com/eik-lib/core/issues/638)) ([cf29a68](https://github.com/eik-lib/core/commit/cf29a6838622360f8c80bc83c86d07536d580f33)), closes [#1](https://github.com/eik-lib/core/issues/1) [#2](https://github.com/eik-lib/core/issues/2) [#3](https://github.com/eik-lib/core/issues/3) [#6](https://github.com/eik-lib/core/issues/6)
+* revert to pre-atomic-write implementation ([#643](https://github.com/eik-lib/core/issues/643)) ([add3724](https://github.com/eik-lib/core/commit/add3724d2150ae24e8fe212648f9cefb30cdbe1b)), closes [#1](https://github.com/eik-lib/core/issues/1) [#2](https://github.com/eik-lib/core/issues/2) [#3](https://github.com/eik-lib/core/issues/3) [#6](https://github.com/eik-lib/core/issues/6)
 
 ## [2.1.78](https://github.com/eik-lib/core/compare/v2.1.77...v2.1.78) (2026-08-17)
 

package/lib/handlers/alias.put.js

@@ -8,7 +8,7 @@ import {
 	createFilePathToAlias,
 	createFilePathToAliasOrigin,
 } from "../utils/path-builders-fs.js";
-import { decodeUriComponent, writeJSONWithOptions } from "../utils/utils.js";
+import { decodeUriComponent, writeJSON } from "../utils/utils.js";
 import { createURIToAlias } from "../utils/path-builders-uri.js";
 import MultipartParser from "../multipart/parser.js";
 import HttpIncoming from "../classes/http-incoming.js";
@@ -109,18 +109,8 @@ const AliasPut = class AliasPut {
 					);
 
 					try {
-						await writeJSONWithOptions(
-							this._sink,
-							path,
-							alias,
-							"application/json",
-							{ ifNotExists: true },
-						);
+						await writeJSON(this._sink, path, alias, "application/json");
 					} catch (error) {
-						const err = /** @type {any} */ (error);
-						if (err.code === "ALREADY_EXISTS") {
-							throw new HttpError.Conflict();
-						}
 						this._log.error(
 							`alias:put - Failed writing alias to sink - Pathname: ${path}`,
 						);

package/lib/handlers/map.put.js

@@ -20,8 +20,7 @@ import {
 	decodeUriComponent,
 	streamCollector,
 	writeJSON,
-	writeJSONWithOptions,
-	readJSONWithGeneration,
+	readJSON,
 } from "../utils/utils.js";
 
 /**
@@ -173,7 +172,7 @@ const MapPut = class MapPut {
 
 	/**
 	 * @param {any} incoming
-	 * @returns {Promise<{ versions: InstanceType<typeof Versions>, generation: string }>}
+	 * @returns {Promise<InstanceType<typeof Versions>>}
 	 */
 	async _readVersions(incoming) {
 		const path = createFilePathToVersion(incoming);
@@ -187,65 +186,30 @@ const MapPut = class MapPut {
 			this._log.info(
 				`map:put - Version meta file did not exist in sink - Create new - Pathname: ${path}`,
 			);
-			return { versions: new Versions(incoming), generation: "" };
+			return new Versions(incoming);
 		}
 
 		// File exists. Any failure here must propagate rather than be
 		// swallowed — silently falling back to an empty Versions object
 		// would cause _writeVersions to overwrite the index and erase the
 		// entire version history.
-		const { data, generation } = await readJSONWithGeneration(this._sink, path);
+		const obj = await readJSON(this._sink, path);
 		this._log.info(
 			`map:put - Successfully read version meta file from sink - Pathname: ${path}`,
 		);
-		return { versions: new Versions(data), generation };
+		return new Versions(obj);
 	}
 
 	/**
-	 * Writes versions.json with compare-and-swap semantics when a generation
-	 * token is available. On conflict the read-modify-write cycle is retried.
-	 *
 	 * @param {any} incoming
-	 * @param {InstanceType<typeof Versions>} versions
-	 * @param {string} generation
-	 * @param {string} pVersion
-	 * @param {string} integrity
+	 * @param {any} versions
 	 */
-	async _writeVersions(incoming, versions, generation, pVersion, integrity) {
+	async _writeVersions(incoming, versions) {
 		const path = createFilePathToVersion(incoming);
-		const maxRetries = 3;
-		/** @type {{ ifGenerationMatch?: string | number }} */
-		let options = generation ? { ifGenerationMatch: generation } : {};
-		let currentVersions = versions;
-		for (let attempt = 0; attempt <= maxRetries; attempt++) {
-			try {
-				await writeJSONWithOptions(
-					this._sink,
-					path,
-					currentVersions,
-					"application/json",
-					options,
-				);
-				this._log.info(
-					`map:put - Successfully wrote version meta file to sink - Pathname: ${path}`,
-				);
-				return;
-			} catch (error) {
-				const err = /** @type {any} */ (error);
-				if (err.code === "CONFLICT" && attempt < maxRetries) {
-					this._log.info(
-						`map:put - versions.json conflict on attempt ${attempt + 1}, retrying`,
-					);
-					const { versions: fresh, generation: newGen } =
-						await this._readVersions(incoming);
-					fresh.setVersion(pVersion, integrity);
-					currentVersions = fresh;
-					options = newGen ? { ifGenerationMatch: newGen } : {};
-					continue;
-				}
-				throw error;
-			}
-		}
+		await writeJSON(this._sink, path, versions, "application/json");
+		this._log.info(
+			`map:put - Successfully wrote version meta file to sink - Pathname: ${path}`,
+		);
 	}
 
 	/**
@@ -294,13 +258,11 @@ const MapPut = class MapPut {
 			org,
 		});
 
-		const { versions, generation } = await this._readVersions(incoming).catch(
-			() => {
-				const e = new HttpError.BadGateway();
-				end({ labels: { success: false, status: e.status, type: "map" } });
-				throw e;
-			},
-		);
+		const versions = await this._readVersions(incoming).catch(() => {
+			const e = new HttpError.BadGateway();
+			end({ labels: { success: false, status: e.status, type: "map" } });
+			throw e;
+		});
 
 		if (!versions.check(pVersion)) {
 			this._log.info(
@@ -315,13 +277,7 @@ const MapPut = class MapPut {
 		versions.setVersion(pVersion, integrity);
 
 		try {
-			await this._writeVersions(
-				incoming,
-				versions,
-				generation,
-				pVersion,
-				integrity,
-			);
+			await this._writeVersions(incoming, versions);
 			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
 			const e = new HttpError.BadGateway();

package/lib/handlers/pkg.put.js

@@ -13,8 +13,7 @@ import {
 import {
 	decodeUriComponent,
 	writeJSON,
-	writeJSONWithOptions,
-	readJSONWithGeneration,
+	readJSON,
 	readEikJson,
 } from "../utils/utils.js";
 import { createURIPathToPkgLog } from "../utils/path-builders-uri.js";
@@ -130,12 +129,11 @@ const PkgPut = class PkgPut {
 			type: incoming.type,
 		};
 		const eikJsonPath = createFilePathToEikJson(incoming);
-		const buffer = await writeJSONWithOptions(
+		const buffer = await writeJSON(
 			this._sink,
 			eikJsonPath,
 			content,
 			"application/json",
-			{ ifNotExists: true },
 		);
 		this._log.info(
 			`pkg:put - Successfully wrote eik.json to sink - Pathname: ${eikJsonPath}`,
@@ -157,7 +155,7 @@ const PkgPut = class PkgPut {
 
 	/**
 	 * @param {any} incoming
-	 * @returns {Promise<{ versions: InstanceType<typeof Versions>, generation: string }>}
+	 * @returns {Promise<InstanceType<typeof Versions>>}
 	 */
 	async _readVersions(incoming) {
 		const path = createFilePathToVersion(incoming);
@@ -171,18 +169,18 @@ const PkgPut = class PkgPut {
 			this._log.info(
 				`pkg:put - Version meta file did not exist in sink - Create new - Pathname: ${path}`,
 			);
-			return { versions: new Versions(incoming), generation: "" };
+			return new Versions(incoming);
 		}
 
 		// File exists. Any failure here (GCS error, corrupt JSON, network
 		// timeout) must propagate rather than be swallowed — silently falling
 		// back to an empty Versions object would cause _writeVersions to
 		// overwrite the index and erase the entire version history.
-		const { data, generation } = await readJSONWithGeneration(this._sink, path);
+		const obj = await readJSON(this._sink, path);
 		this._log.info(
 			`pkg:put - Successfully read version meta file from sink - Pathname: ${path}`,
 		);
-		return { versions: new Versions(data), generation };
+		return new Versions(obj);
 	}
 
 	/**
@@ -207,50 +205,15 @@ const PkgPut = class PkgPut {
 	}
 
 	/**
-	 * Writes versions.json with compare-and-swap semantics when a generation
-	 * token is available. On conflict the read-modify-write cycle is retried.
-	 *
 	 * @param {any} incoming
-	 * @param {InstanceType<typeof Versions>} versions
-	 * @param {string} generation
-	 * @param {string} pVersion
-	 * @param {string} integrity
+	 * @param {any} versions
 	 */
-	async _writeVersions(incoming, versions, generation, pVersion, integrity) {
+	async _writeVersions(incoming, versions) {
 		const path = createFilePathToVersion(incoming);
-		const maxRetries = 3;
-		/** @type {{ ifGenerationMatch?: string | number }} */
-		let options = generation ? { ifGenerationMatch: generation } : {};
-		let currentVersions = versions;
-		for (let attempt = 0; attempt <= maxRetries; attempt++) {
-			try {
-				await writeJSONWithOptions(
-					this._sink,
-					path,
-					currentVersions,
-					"application/json",
-					options,
-				);
-				this._log.info(
-					`pkg:put - Successfully wrote version meta file to sink - Pathname: ${path}`,
-				);
-				return;
-			} catch (error) {
-				const err = /** @type {any} */ (error);
-				if (err.code === "CONFLICT" && attempt < maxRetries) {
-					this._log.info(
-						`pkg:put - versions.json conflict on attempt ${attempt + 1}, retrying`,
-					);
-					const { versions: fresh, generation: newGen } =
-						await this._readVersions(incoming);
-					fresh.setVersion(pVersion, integrity);
-					currentVersions = fresh;
-					options = newGen ? { ifGenerationMatch: newGen } : {};
-					continue;
-				}
-				throw error;
-			}
-		}
+		await writeJSON(this._sink, path, versions, "application/json");
+		this._log.info(
+			`pkg:put - Successfully wrote version meta file to sink - Pathname: ${path}`,
+		);
 	}
 
 	/**
@@ -312,13 +275,11 @@ const PkgPut = class PkgPut {
 			throw e;
 		}
 
-		const { versions, generation } = await this._readVersions(incoming).catch(
-			() => {
-				const e = new HttpError.BadGateway();
-				end({ labels: { success: false, status: e.status, type } });
-				throw e;
-			},
-		);
+		const versions = await this._readVersions(incoming).catch(() => {
+			const e = new HttpError.BadGateway();
+			end({ labels: { success: false, status: e.status, type } });
+			throw e;
+		});
 
 		const { pkg, eikJson } = await this._parser(incoming);
 
@@ -327,15 +288,8 @@ const PkgPut = class PkgPut {
 		let eikJsonAsset;
 		try {
 			eikJsonAsset = await this._writeEikJson(incoming, eikJson);
+			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
-			const err = /** @type {any} */ (error);
-			if (err.code === "ALREADY_EXISTS") {
-				// Another replica committed this version while this upload was in
-				// flight. Treat it as a conflict identical to the early existence check.
-				const e = new HttpError.Conflict();
-				end({ labels: { success: false, status: e.status, type } });
-				throw e;
-			}
 			const e = new HttpError.BadGateway();
 			end({ labels: { success: false, status: e.status, type } });
 			throw e;
@@ -355,14 +309,10 @@ const PkgPut = class PkgPut {
 			throw e;
 		}
 
+		versions.setVersion(pVersion, pkg.integrity);
+
 		try {
-			await this._writeVersions(
-				incoming,
-				versions,
-				generation,
-				pVersion,
-				pkg.integrity,
-			);
+			await this._writeVersions(incoming, versions);
 			// eslint-disable-next-line no-unused-vars
 		} catch (error) {
 			const e = new HttpError.BadGateway();

package/lib/multipart/parser.js

@@ -162,9 +162,7 @@ const MultipartParser = class MultipartParser {
 			// Without a cap, a tar with thousands of files would open an equal
 			// number of concurrent GCS resumable uploads or filesystem write
 			// streams, exhausting the connection pool or file descriptor limit.
-			// 8 keeps the peak concurrent GCS API calls below the default
-			// EventEmitter maxListeners threshold of 10.
-			const MAX_CONCURRENT_WRITES = 8;
+			const MAX_CONCURRENT_WRITES = 16;
 			let runningWrites = 0;
 			/** @type {import("tar").ReadEntry[]} */
 			const pendingEntries = [];

package/lib/utils/utils.js

@@ -107,109 +107,9 @@ const decodeUriComponent = (value) => {
 	return decodeURIComponent(value);
 };
 
-/**
- * Like readJSON but also returns the generation token from the ReadFile,
- * which can be passed back to writeJSONWithOptions as ifGenerationMatch
- * for compare-and-swap semantics.
- *
- * @param {any} sink
- * @param {string} path
- * @returns {Promise<{ data: any, generation: string }>}
- */
-const readJSONWithGeneration = (sink, path) =>
-	// eslint-disable-next-line no-async-promise-executor
-	new Promise(async (resolve, reject) => {
-		try {
-			/** @type {any[]} */
-			const buffer = [];
-			const from = await sink.read(path);
-
-			const to = new Writable({
-				objectMode: false,
-				write(chunk, encoding, callback) {
-					buffer.push(chunk);
-					callback();
-				},
-			});
-
-			pipeline(from.stream, to, (error) => {
-				if (error) return reject(error);
-				const str = Buffer.concat(buffer).toString("utf8");
-				try {
-					const obj = JSON.parse(str);
-					return resolve({ data: obj, generation: from.generation ?? "" });
-				} catch (err) {
-					return reject(err);
-				}
-			});
-		} catch (error) {
-			reject(error);
-		}
-	});
-
-/**
- * Like writeJSON but accepts sink write options (e.g. { ifNotExists, ifGenerationMatch })
- * for atomic conditional writes.
- *
- * @param {any} sink
- * @param {string} path
- * @param {any} obj
- * @param {string} contentType
- * @param {{ ifNotExists?: boolean, ifGenerationMatch?: string | number }} [options]
- */
-const writeJSONWithOptions = (sink, path, obj, contentType, options = {}) =>
-	// eslint-disable-next-line no-async-promise-executor
-	new Promise(async (resolve, reject) => {
-		try {
-			const buffer = Buffer.from(JSON.stringify(obj));
-
-			const from = new Readable({
-				objectMode: false,
-				read() {
-					this.push(buffer);
-					this.push(null);
-				},
-			});
-
-			const to = await sink.write(path, contentType, options);
-
-			pipeline(from, to, (error) => {
-				if (error) {
-					// GCS returns HTTP 412 Precondition Failed when a conditional
-					// write constraint was not met. Reclassify using the options
-					// that triggered the condition so callers receive a meaningful
-					// error code rather than the raw HTTP status.
-					const err = /** @type {any} */ (error);
-					if (err.code === 412) {
-						if (options.ifNotExists) {
-							return reject(
-								Object.assign(new Error(`File already exists: ${path}`), {
-									code: "ALREADY_EXISTS",
-								}),
-							);
-						}
-						if (options.ifGenerationMatch !== undefined) {
-							return reject(
-								Object.assign(new Error(`Generation mismatch: ${path}`), {
-									code: "CONFLICT",
-								}),
-							);
-						}
-					}
-					return reject(error);
-				}
-				return resolve(buffer);
-			});
-		} catch (error) {
-			reject(error);
-		}
-	});
-
 export {
 	readJSON,
-	readJSONWithGeneration,
 	writeJSON,
-	writeJSONWithOptions,
 	streamCollector,
 	etagFromFsStat,
 	decodeUriComponent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eik/core",
-  "version": "2.1.83",
+  "version": "2.2.1",
   "description": "Core server package",
   "main": "lib/main.js",
   "types": "./types/main.d.ts",
@@ -31,8 +31,8 @@
   "dependencies": {
     "@eik/common": "5.2.0",
     "@eik/sink": "1.2.7",
-    "@eik/sink-file-system": "2.1.0",
-    "@eik/sink-memory": "2.1.0",
+    "@eik/sink-file-system": "2.2.0",
+    "@eik/sink-memory": "2.2.1",
     "@metrics/client": "2.5.5",
     "abslog": "2.4.4",
     "busboy": "1.6.0",

package/types/handlers/map.put.d.ts

@@ -42,23 +42,14 @@ declare const MapPut: {
         }): Promise<string>;
         /**
          * @param {any} incoming
-         * @returns {Promise<{ versions: InstanceType<typeof Versions>, generation: string }>}
+         * @returns {Promise<InstanceType<typeof Versions>>}
          */
-        _readVersions(incoming: any): Promise<{
-            versions: InstanceType<typeof Versions>;
-            generation: string;
-        }>;
+        _readVersions(incoming: any): Promise<InstanceType<typeof Versions>>;
         /**
-         * Writes versions.json with compare-and-swap semantics when a generation
-         * token is available. On conflict the read-modify-write cycle is retried.
-         *
          * @param {any} incoming
-         * @param {InstanceType<typeof Versions>} versions
-         * @param {string} generation
-         * @param {string} pVersion
-         * @param {string} integrity
+         * @param {any} versions
          */
-        _writeVersions(incoming: any, versions: InstanceType<typeof Versions>, generation: string, pVersion: string, integrity: string): Promise<void>;
+        _writeVersions(incoming: any, versions: any): Promise<void>;
         /**
          * @param {any} req
          * @param {any} user

package/types/handlers/pkg.put.d.ts

@@ -82,27 +82,18 @@ declare const PkgPut: {
         _writeEikJson(incoming: any, capturedEikJson: Record<string, any> | null): Promise<InstanceType<typeof Asset>>;
         /**
          * @param {any} incoming
-         * @returns {Promise<{ versions: InstanceType<typeof Versions>, generation: string }>}
+         * @returns {Promise<InstanceType<typeof Versions>>}
          */
-        _readVersions(incoming: any): Promise<{
-            versions: InstanceType<typeof Versions>;
-            generation: string;
-        }>;
+        _readVersions(incoming: any): Promise<InstanceType<typeof Versions>>;
         /**
          * @param {any} incoming
          */
         _readVersion(incoming: any): Promise<boolean>;
         /**
-         * Writes versions.json with compare-and-swap semantics when a generation
-         * token is available. On conflict the read-modify-write cycle is retried.
-         *
          * @param {any} incoming
-         * @param {InstanceType<typeof Versions>} versions
-         * @param {string} generation
-         * @param {string} pVersion
-         * @param {string} integrity
+         * @param {any} versions
          */
-        _writeVersions(incoming: any, versions: InstanceType<typeof Versions>, generation: string, pVersion: string, integrity: string): Promise<void>;
+        _writeVersions(incoming: any, versions: any): Promise<void>;
         /**
          * @param {any} req
          * @param {any} user

package/types/utils/utils.d.ts

@@ -3,19 +3,6 @@
  * @param {string} path
  */
 export function readJSON(sink: any, path: string): Promise<any>;
-/**
- * Like readJSON but also returns the generation token from the ReadFile,
- * which can be passed back to writeJSONWithOptions as ifGenerationMatch
- * for compare-and-swap semantics.
- *
- * @param {any} sink
- * @param {string} path
- * @returns {Promise<{ data: any, generation: string }>}
- */
-export function readJSONWithGeneration(sink: any, path: string): Promise<{
-    data: any;
-    generation: string;
-}>;
 /**
  * @param {any} sink
  * @param {string} path
@@ -23,20 +10,6 @@ export function readJSONWithGeneration(sink: any, path: string): Promise<{
  * @param {string} contentType
  */
 export function writeJSON(sink: any, path: string, obj: any, contentType: string): Promise<any>;
-/**
- * Like writeJSON but accepts sink write options (e.g. { ifNotExists, ifGenerationMatch })
- * for atomic conditional writes.
- *
- * @param {any} sink
- * @param {string} path
- * @param {any} obj
- * @param {string} contentType
- * @param {{ ifNotExists?: boolean, ifGenerationMatch?: string | number }} [options]
- */
-export function writeJSONWithOptions(sink: any, path: string, obj: any, contentType: string, options?: {
-    ifNotExists?: boolean;
-    ifGenerationMatch?: string | number;
-}): Promise<any>;
 /**
  * @param {any} from
  */