apache-iggy 0.8.1-edge.3 → 0.9.0-edge.1

package/README.md

@@ -57,11 +57,7 @@ from the SDK command table use `Operation::NonReplicated` and carry the command
 code in the request header's reserved field. The server remains authoritative
 for classifying or rejecting extension commands.
 
-The same npm package supports both framing modes. VSR currently supports TCP
-only and restricts `Client` to one pooled connection because authentication,
-request sequencing, and consumer-group assignments belong to one consensus
-session. Configurations requesting VSR over TLS or more than one pooled
-connection fail before a socket is opened.
+The same npm package supports both framing modes over TCP and TLS. VSR restricts `Client` to one pooled connection because authentication, request sequencing, and consumer-group assignments belong to one consensus session. Configurations requesting more than one pooled connection fail before a socket is opened.
 
 VSR authentication translates the existing password and personal-access-token
 login APIs into the register handshake required by the consensus protocol. A

package/dist/client/client.config.js

@@ -24,8 +24,6 @@ export const normalizeClientConfig = (config) => {
     if (!Number.isSafeInteger(maxResponseFrameSize) ||
         maxResponseFrameSize < 256)
         throw new TypeError('maxResponseFrameSize must be a safe integer of at least 256 bytes');
-    if (protocol === 'vsr' && config.transport === 'TLS')
-        throw new TypeError('VSR framing currently supports the TCP transport only');
     if (protocol === 'vsr' &&
         ((config.poolSize?.min ?? 1) > 1 || (config.poolSize?.max ?? 1) > 1))
         throw new TypeError('VSR clients currently support exactly one pooled connection');

package/dist/client/client.config.test.js

@@ -50,12 +50,15 @@ describe('normalizeClientConfig', () => {
             protocol: 'auto'
         }), /unsupported wire protocol/);
     });
-    it('rejects VSR over an untested TLS transport', () => {
-        assert.throws(() => normalizeClientConfig({
+    it('supports VSR over TLS', () => {
+        const normalized = normalizeClientConfig({
             ...config(),
             protocol: 'vsr',
             transport: 'TLS'
-        }), /TCP transport only/);
+        });
+        assert.equal(normalized.protocol, 'vsr');
+        assert.equal(normalized.transport, 'TLS');
+        assert.deepEqual(normalized.poolSize, { min: 1, max: 1 });
     });
     it('rejects unsafe response frame limits', () => {
         for (const maxResponseFrameSize of [0, 255, 1.5, Number.MAX_VALUE])

package/dist/client/client.socket.test.js

@@ -17,8 +17,10 @@
 //
 import assert from 'node:assert/strict';
 import { once } from 'node:events';
+import { readFileSync } from 'node:fs';
 import { createServer } from 'node:net';
 import { describe, it } from 'node:test';
+import { createServer as createTlsServer } from 'node:tls';
 import { COMMAND_CODE } from '../wire/command.code.js';
 import { ResponseError } from '../wire/error.utils.js';
 import { Command2, EVICTION_OFFSET, EvictionReason, HEADER_SIZE, REPLY_OFFSET, REQUEST_OFFSET } from '../wire/vsr/header.js';
@@ -26,10 +28,13 @@ import { Operation } from '../wire/vsr/operation.js';
 import { VsrEvictionError } from '../wire/vsr/reply.js';
 import { CommandResponseStream } from './client.socket.js';
 const TEST_SESSION = 42n;
+const TLS_CERTIFICATE = readFileSync(new URL('../../../../core/certs/iggy_cert.pem', import.meta.url));
+const TLS_KEY = readFileSync(new URL('../../../../core/certs/iggy_key.pem', import.meta.url));
+const TLS_CA_CERTIFICATE = readFileSync(new URL('../../../../core/certs/iggy_ca_cert.pem', import.meta.url));
 /** Loopback server speaking just enough VSR framing for the client tests. */
-const startVsrServer = async (handler) => {
+const startVsrServer = async (handler, transport = 'TCP') => {
     const frames = [];
-    const server = createServer((socket) => {
+    const handleConnection = (socket) => {
         let pending = Buffer.alloc(0);
         socket.on('data', (data) => {
             pending = Buffer.concat([pending, data]);
@@ -44,7 +49,10 @@ const startVsrServer = async (handler) => {
             }
         });
         socket.on('error', () => { });
-    });
+    };
+    const server = transport === 'TLS'
+        ? createTlsServer({ cert: TLS_CERTIFICATE, key: TLS_KEY }, handleConnection)
+        : createServer(handleConnection);
     server.listen(0, '127.0.0.1');
     await once(server, 'listening');
     return {
@@ -160,6 +168,28 @@ const vsrConfig = (port) => ({
     reconnect: { enabled: false, interval: 100, maxRetries: 1 }
 });
 describe('VSR client socket', () => {
+    it('exchanges VSR frames over TLS', async () => {
+        const server = await startVsrServer((frame, socket) => singleNodeHandler(server.port)(frame, socket), 'TLS');
+        const client = new CommandResponseStream({
+            ...vsrConfig(server.port),
+            transport: 'TLS',
+            options: {
+                host: '127.0.0.1',
+                port: server.port,
+                servername: 'localhost',
+                ca: TLS_CA_CERTIFICATE
+            }
+        });
+        try {
+            const response = await client.sendCommand(60_015, Buffer.from('tls'));
+            assert.equal(response.status, 0);
+            assert.equal(server.frames.length, 3);
+        }
+        finally {
+            client.destroy();
+            await server.close();
+        }
+    });
     it('registers one session before the first authenticated command', async () => {
         const server = await startVsrServer((frame, socket) => singleNodeHandler(server.port)(frame, socket));
         const client = new CommandResponseStream(vsrConfig(server.port));

package/dist/client/client.utils.d.ts

@@ -27,7 +27,6 @@ export declare const handleResponseTransform: () => Transform;
  * @returns True if the response indicates success with no data
  */
 export declare const deserializeVoidResponse: (r: CommandResponse) => boolean;
-export declare const deserializeStatusResponse: (r: CommandResponse) => boolean;
 /**
  * Serializes a command and its payload into a buffer for sending to the server.
  * Creates the wire format: [payload_size (4 bytes)][command (4 bytes)][payload]

package/dist/client/client.utils.js

@@ -59,7 +59,6 @@ export const handleResponseTransform = () => new Transform({
  * @returns True if the response indicates success with no data
  */
 export const deserializeVoidResponse = (r) => r.status === 0 && r.data.length === 0;
-export const deserializeStatusResponse = (r) => r.status === 0;
 /** Length of the command code in bytes */
 const COMMAND_LENGTH = 4;
 /**

package/dist/client/client.utils.test.js

@@ -17,9 +17,8 @@
 //
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { handleResponse, deserializeVoidResponse, deserializeStatusResponse } from './client.utils.js';
+import { handleResponse, deserializeVoidResponse } from './client.utils.js';
 const SUCCESS = 0;
-const ERROR = 1;
 describe('handleResponse', () => {
     it('bounds data to the length field, not the full buffer', () => {
         // Server says: status=0, length=0, no payload.
@@ -40,19 +39,4 @@ describe('handleResponse', () => {
         assert.equal(deserializeVoidResponse(r), true);
     });
 });
-describe('deserializeStatusResponse', () => {
-    it('returns true when status is SUCCESS and data is empty', () => {
-        const r = { status: SUCCESS, length: 0, data: Buffer.alloc(0) };
-        assert.equal(deserializeStatusResponse(r), true);
-    });
-    it('returns true when status is SUCCESS and data is non-empty (e.g. SendMessages server payload)', () => {
-        // Key difference from deserializeVoidResponse: non-empty data is accepted.
-        const r = { status: SUCCESS, length: 4, data: Buffer.from([1, 2, 3, 4]) };
-        assert.equal(deserializeStatusResponse(r), true);
-    });
-    it('returns false when status is an error code', () => {
-        const r = { status: ERROR, length: 0, data: Buffer.alloc(0) };
-        assert.equal(deserializeStatusResponse(r), false);
-    });
-});
 //# sourceMappingURL=client.utils.test.js.map

package/dist/e2e/tcp.send-message.e2e.js

@@ -22,6 +22,9 @@ import { generateMessages } from '../tcp.sm.utils.js';
 import { getTestClient } from './test-client.utils.js';
 describe('e2e -> message', async () => {
     const c = getTestClient();
+    // Only the VSR lane reaches a server that reports offsets. The classic lane
+    // runs against the legacy server, which commits without confirming.
+    const vsr = process.env.IGGY_TEST_PROTOCOL === 'vsr';
     const streamName = 'e2e-stream-934';
     const topicName = 'e2e-topic-832';
     const partitionId = 0;
@@ -40,7 +43,13 @@ describe('e2e -> message', async () => {
         partition: Partitioning.PartitionId(partitionId)
     };
     it('e2e -> message::send', async () => {
-        assert.ok(await c.message.send(msg));
+        const { confirmations } = await c.message.send(msg);
+        if (!vsr) {
+            assert.equal(confirmations.length, 0);
+            return;
+        }
+        assert.equal(confirmations.length, 1);
+        assert.equal(confirmations[0].partitionId, partitionId);
     });
     it('e2e -> message::poll/last', async () => {
         const pollReq = {
@@ -143,6 +152,20 @@ describe('e2e -> message', async () => {
         });
         assert.deepEqual(offset, { partitionId: 0, currentOffset: 5n, storedOffset: 2n });
     });
+    it('e2e -> message::send/next batch', async () => {
+        const { confirmations } = await c.message.send({
+            ...msg,
+            messages: generateMessages(3)
+        });
+        if (!vsr) {
+            assert.equal(confirmations.length, 0);
+            return;
+        }
+        // Landing behind the already committed batch is the part no placeholder
+        // confirmation could reproduce.
+        assert.equal(confirmations.length, 1);
+        assert.equal(confirmations[0].baseOffset, BigInt(msg.messages.length));
+    });
     it('e2e -> message::cleanup', async () => {
         assert.ok(await c.stream.delete({ streamId: streamName }));
         assert.ok(await c.session.logout());

package/dist/e2e/tls.system.e2e.js

@@ -46,9 +46,13 @@ const caCertPath = process.env.E2E_ROOT_CA_CERT
 const getTlsClient = () => {
     const [, port] = getIggyAddress();
     const caCert = readFileSync(caCertPath);
+    const protocol = process.env.IGGY_TEST_PROTOCOL === 'vsr'
+        ? 'vsr'
+        : 'classic';
     // The server certificate SAN is DNS:localhost, so we connect via 'localhost'
     // for proper hostname verification (consistent with Python and C# TLS tests).
     return new Client({
+        protocol,
         transport: 'TLS',
         options: {
             port,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type Id, PollingStrategy, Consumer, Partitioning, HeaderValue, HeaderKeyFactory, } from "./wire/index.js";
+export { type Id, PollingStrategy, Consumer, Partitioning, HeaderValue, HeaderKeyFactory, type SendMessagesConfirmation, type SendMessagesResponse, } from "./wire/index.js";
 export * from "./client/index.js";
 export * from "./stream/index.js";
 export { DeserializeError, ResponseError } from './wire/error.utils.js';

package/dist/tcp.sm.utils.d.ts

@@ -55,7 +55,7 @@ export declare const generateMessages: (count?: number) => ({
     }[];
     id: string;
 })[];
-export declare const sendSomeMessages: (s: ClientProvider) => (streamId: Id, topicId: Id, partition: Partitioning) => Promise<true>;
+export declare const sendSomeMessages: (s: ClientProvider) => (streamId: Id, topicId: Id, partition: Partitioning) => Promise<import("./wire/index.js").SendMessagesResponse>;
 export declare const formatPolledMessages: (msgs: Message[]) => {
     id: string | bigint;
     offset: bigint;

package/dist/wire/command-set.d.ts

@@ -75,7 +75,7 @@ declare const offsetAPI: (c: ClientProvider) => {
 type OffsetAPI = ReturnType<typeof offsetAPI>;
 declare const messageAPI: (c: ClientProvider) => {
     poll: (request: import("./message/poll-messages.command.js").PollMessages) => Promise<import("./index.js").PollMessagesResponse>;
-    send: (arg: import("./message/send-messages.command.js").SendMessages) => Promise<boolean>;
+    send: (arg: import("./message/send-messages.command.js").SendMessages) => Promise<import("./message/send-messages.command.js").SendMessagesResponse>;
     flushUnsavedBuffers: (arg: import("./message/flush-unsaved-buffers.command.js").FlushUnsavedBuffer) => Promise<boolean>;
 };
 type MessageAPI = ReturnType<typeof messageAPI>;

package/dist/wire/message/send-messages.command.d.ts

@@ -1,6 +1,7 @@
 import { type Id } from '../identifier.utils.js';
 import { type CreateMessage } from './message.utils.js';
 import type { Partitioning } from './partitioning.utils.js';
+import type { CommandResponse } from '../../client/client.type.js';
 /**
  * Parameters for the send messages command.
  */
@@ -14,6 +15,33 @@ export type SendMessages = {
     /** Optional partitioning strategy */
     partition?: Partitioning;
 };
+/** Commit confirmation for one partition written by a send. */
+export type SendMessagesConfirmation = {
+    /** Numeric id of the stream the batch was written to */
+    streamId: number;
+    /** Numeric id of the topic the batch was written to */
+    topicId: number;
+    /** Partition the batch was written to */
+    partitionId: number;
+    /**
+     * Offset assigned to the first message of the batch in that partition.
+     *
+     * Delivery is at-least-once, so an earlier retry of the same batch may
+     * already have committed at a lower offset: this never identifies a batch
+     * uniquely. A batch is confirmed once it is committed in memory, not once it
+     * is fsynced, so a crash-restart can stamp a later batch with an offset a
+     * client has already recorded.
+     */
+    baseOffset: bigint;
+};
+/**
+ * Outcome of a successful send, one confirmation per written partition. The
+ * legacy server returns an empty list: it commits without reporting offsets.
+ */
+export type SendMessagesResponse = {
+    /** Commit confirmations, one per partition the batch was written to */
+    confirmations: SendMessagesConfirmation[];
+};
 /**
  * Send messages command definition.
  * Publishes messages to a topic.
@@ -21,10 +49,11 @@ export type SendMessages = {
 export declare const SEND_MESSAGES: {
     code: number;
     serialize: ({ streamId, topicId, messages, partition }: SendMessages) => Buffer<ArrayBuffer>;
-    deserialize: (r: import("../../index.js").CommandResponse) => boolean;
+    deserialize: (r: CommandResponse) => SendMessagesResponse;
 };
 /**
- * Executable send messages command function.
+ * Executable send messages command function. Resolves to the commit
+ * confirmations of the written partitions, empty against the legacy server.
  */
-export declare const sendMessages: (getClient: import("../../index.js").ClientProvider) => (arg: SendMessages) => Promise<boolean>;
+export declare const sendMessages: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: SendMessages) => Promise<SendMessagesResponse>;
 //# sourceMappingURL=send-messages.command.d.ts.map

package/dist/wire/message/send-messages.command.js

@@ -16,9 +16,46 @@
 // under the License.
 //
 import { serializeSendMessages } from './message.utils.js';
-import { deserializeStatusResponse } from '../../client/client.utils.js';
+import { DeserializeError } from '../error.utils.js';
 import { wrapCommand } from '../command.utils.js';
 import { COMMAND_CODE } from '../command.code.js';
+/** Size of the confirmation count prefixing the list. */
+const CONFIRMATIONS_COUNT_SIZE = 4;
+/**
+ * Size of one confirmation entry:
+ * `stream_id(4) + topic_id(4) + partition_id(4) + base_offset(8)`.
+ */
+const CONFIRMATION_SIZE = 20;
+/**
+ * Decodes the reply body of a send: `[confirmations_count:4]` then that many
+ * `[stream_id:4 topic_id:4 partition_id:4 base_offset:8]` entries.
+ *
+ * The legacy server reports a commit by sending no body at all, so absence
+ * decodes to no confirmations instead of surfacing as a decode failure.
+ */
+const deserializeSendMessages = (data) => {
+    if (data.length === 0)
+        return { confirmations: [] };
+    if (data.length < CONFIRMATIONS_COUNT_SIZE)
+        throw new DeserializeError('send messages confirmation count is truncated');
+    const count = data.readUInt32LE(0);
+    const expected = CONFIRMATIONS_COUNT_SIZE + count * CONFIRMATION_SIZE;
+    if (expected > data.length)
+        throw new DeserializeError('send messages confirmation list is truncated');
+    if (expected !== data.length)
+        throw new DeserializeError('send messages confirmations have trailing bytes');
+    const confirmations = new Array(count);
+    for (let index = 0; index < count; index += 1) {
+        const at = CONFIRMATIONS_COUNT_SIZE + index * CONFIRMATION_SIZE;
+        confirmations[index] = {
+            streamId: data.readUInt32LE(at),
+            topicId: data.readUInt32LE(at + 4),
+            partitionId: data.readUInt32LE(at + 8),
+            baseOffset: data.readBigUInt64LE(at + 12)
+        };
+    }
+    return { confirmations };
+};
 /**
  * Send messages command definition.
  * Publishes messages to a topic.
@@ -28,10 +65,11 @@ export const SEND_MESSAGES = {
     serialize: ({ streamId, topicId, messages, partition }) => {
         return serializeSendMessages(streamId, topicId, messages, partition);
     },
-    deserialize: deserializeStatusResponse
+    deserialize: (r) => deserializeSendMessages(r.data)
 };
 /**
- * Executable send messages command function.
+ * Executable send messages command function. Resolves to the commit
+ * confirmations of the written partitions, empty against the legacy server.
  */
 export const sendMessages = wrapCommand(SEND_MESSAGES);
 //# sourceMappingURL=send-messages.command.js.map

package/dist/wire/message/send-messages.command.test.js

@@ -18,10 +18,34 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { uuidv7, uuidv4 } from "uuidv7";
-import { SEND_MESSAGES } from "./send-messages.command.js";
+import { SEND_MESSAGES, } from "./send-messages.command.js";
 import { HeaderValue, HeaderKeyFactory } from "./header.utils.js";
+import { DeserializeError } from "../error.utils.js";
 const SUCCESS = 0;
-const ERROR = 1;
+const CONFIRMATION_SIZE = 20;
+const confirmation = (partitionId) => ({
+    streamId: 1,
+    topicId: 2,
+    partitionId,
+    baseOffset: 42n,
+});
+const serializeConfirmations = (confirmations) => {
+    const b = Buffer.allocUnsafe(4 + confirmations.length * CONFIRMATION_SIZE);
+    b.writeUInt32LE(confirmations.length, 0);
+    confirmations.forEach((c, index) => {
+        const at = 4 + index * CONFIRMATION_SIZE;
+        b.writeUInt32LE(c.streamId, at);
+        b.writeUInt32LE(c.topicId, at + 4);
+        b.writeUInt32LE(c.partitionId, at + 8);
+        b.writeBigUInt64LE(c.baseOffset, at + 12);
+    });
+    return b;
+};
+const response = (data) => ({
+    status: SUCCESS,
+    length: data.length,
+    data,
+});
 describe("SendMessages", () => {
     describe("serialize", () => {
         const t1 = {
@@ -150,19 +174,54 @@ describe("SendMessages", () => {
         });
     });
     describe('deserialize', () => {
-        it('returns true when status is SUCCESS with empty data', () => {
-            const r = { status: SUCCESS, length: 0, data: Buffer.alloc(0) };
-            assert.equal(SEND_MESSAGES.deserialize(r), true);
-        });
-        it('returns true when status is SUCCESS with non-empty server payload', () => {
-            // SendMessages server response includes data (e.g. partition/offset info).
-            // The deserializer must accept non-empty data unlike deserializeVoidResponse.
-            const r = { status: SUCCESS, length: 4, data: Buffer.from([1, 2, 3, 4]) };
-            assert.equal(SEND_MESSAGES.deserialize(r), true);
-        });
-        it('returns false when status is an error code', () => {
-            const r = { status: ERROR, length: 0, data: Buffer.alloc(0) };
-            assert.equal(SEND_MESSAGES.deserialize(r), false);
+        it('reads one confirmation', () => {
+            const confirmations = [confirmation(3)];
+            const r = response(serializeConfirmations(confirmations));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations });
+        });
+        it('reads every confirmation of a multi-partition send', () => {
+            const confirmations = [confirmation(0), confirmation(1), confirmation(2)];
+            const r = response(serializeConfirmations(confirmations));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations });
+        });
+        it('reads the wire layout of a confirmation', () => {
+            const r = response(Buffer.from([
+                0x01, 0x00, 0x00, 0x00, // count
+                0x01, 0x00, 0x00, 0x00, // streamId
+                0x02, 0x00, 0x00, 0x00, // topicId
+                0x03, 0x00, 0x00, 0x00, // partitionId
+                0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // baseOffset
+            ]));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), {
+                confirmations: [
+                    { streamId: 1, topicId: 2, partitionId: 3, baseOffset: 4n }
+                ]
+            });
+        });
+        it('reads a committed send that reports no offsets as an empty list', () => {
+            const r = response(serializeConfirmations([]));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations: [] });
+        });
+        it('reads the bodiless legacy server reply as an empty list', () => {
+            const r = response(Buffer.alloc(0));
+            assert.deepEqual(SEND_MESSAGES.deserialize(r), { confirmations: [] });
+        });
+        it('throws on a truncated body', () => {
+            const data = serializeConfirmations([confirmation(0), confirmation(1)]);
+            for (let i = 1; i < data.length; i += 1)
+                assert.throws(() => SEND_MESSAGES.deserialize(response(data.subarray(0, i))), DeserializeError, `expected error for truncation at byte ${i}`);
+        });
+        it('throws on trailing bytes', () => {
+            const data = Buffer.concat([
+                serializeConfirmations([confirmation(1)]),
+                Buffer.from([0xFF])
+            ]);
+            assert.throws(() => SEND_MESSAGES.deserialize(response(data)), DeserializeError);
+        });
+        it('throws on a count no body could hold', () => {
+            const data = Buffer.alloc(4);
+            data.writeUInt32LE(0xFFFF_FFFF, 0);
+            assert.throws(() => SEND_MESSAGES.deserialize(response(data)), DeserializeError);
         });
     });
 });

package/dist/wire/vsr/register.d.ts

@@ -1,6 +1,6 @@
 /**
  * Packed protocol semver of the wire contract this port implements,
- * `pack(0, 10, 3)` per `core/binary_protocol/src/version.rs`. Bump together
+ * `pack(0, 11, 0)` per `core/binary_protocol/src/version.rs`. Bump together
  * with the Rust `IGGY_PROTOCOL_VERSION` on any wire-incompatible change.
  */
 export declare const IGGY_PROTOCOL_VERSION: number;

package/dist/wire/vsr/register.js

@@ -25,10 +25,10 @@
 import { DeserializeError } from '../error.utils.js';
 /**
  * Packed protocol semver of the wire contract this port implements,
- * `pack(0, 10, 3)` per `core/binary_protocol/src/version.rs`. Bump together
+ * `pack(0, 11, 0)` per `core/binary_protocol/src/version.rs`. Bump together
  * with the Rust `IGGY_PROTOCOL_VERSION` on any wire-incompatible change.
  */
-export const IGGY_PROTOCOL_VERSION = (0 << 20) | (10 << 10) | 3;
+export const IGGY_PROTOCOL_VERSION = (0 << 20) | (11 << 10) | 0;
 const SDK_NAME = 'node-sdk';
 const wireName = (value) => {
     const bytes = Buffer.from(value, 'utf8');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apache-iggy",
   "type": "module",
-  "version": "0.8.1-edge.3",
+  "version": "0.9.0-edge.1",
   "description": "Official Apache Iggy NodeJS SDK",
   "keywords": [
     "iggy",
@@ -58,8 +58,8 @@
   "devDependencies": {
     "@commitlint/cli": "21.2.1",
     "@commitlint/config-conventional": "21.2.0",
-    "@cucumber/cucumber": "13.1.1",
-    "@swc-node/register": "1.12.0",
+    "@cucumber/cucumber": "13.2.0",
+    "@swc-node/register": "1.12.1",
     "@types/debug": "4.1.13",
     "@types/node": "26.1.1",
     "c8": "^12.0.0",