apache-iggy 0.10.0 → 0.10.1-edge.2

package/dist/wire/topic/topic.utils.d.ts

@@ -1,3 +1,4 @@
+import { type PartitionContext } from '../vsr/header.js';
 import type { ValueOf } from '../../type.utils.js';
 import { type ParsedOptions } from '../options.utils.js';
 /**
@@ -12,11 +13,11 @@ export type BaseTopic = {
     createdAt: Date;
     /** Number of partitions */
     partitionsCount: number;
-    /** Compression algorithm used */
+    /** Compression algorithm label, read from the options */
     compressionAlgorithm: number;
-    /** Message expiry time in microseconds (0 = unlimited) */
+    /** Message expiry in microseconds, read from the options (u64 max = never expire) */
     messageExpiry: bigint;
-    /** Maximum topic size in bytes (0 = unlimited) */
+    /** Maximum topic size in bytes, read from the options (u64 max = unlimited) */
     maxTopicSize: bigint;
     /** Total size of the topic in bytes */
     sizeBytes: bigint;
@@ -31,6 +32,8 @@ export type BaseTopic = {
  * Partition information within a topic.
  */
 export type Partition = {
+    /** Partition incarnation, owner generation and metadata op the reply carries */
+    context: PartitionContext;
     /** Partition ID */
     id: number;
     /** Partition creation timestamp */
@@ -101,8 +104,8 @@ export declare const isValidCompressionAlgorithm: (ca: number) => ca is Compress
 export declare const compressionAlgorithmName: (ca: CompressionAlgorithm) => string;
 /**
  * Deserializes a topic header from a buffer.
- * Layout: 50 fixed bytes, name, then two length-prefixed options blocks
- * (client-explicit and server-derived).
+ * Layout: 33 fixed bytes, name, then two length-prefixed options blocks
+ * (client-explicit and server-derived) holding every setting.
  *
  * @param p - Buffer containing serialized topic data
  * @param pos - Starting position in the buffer
@@ -143,5 +146,11 @@ export declare const Durability: {
     readonly Persisted: "persisted";
 };
 export type Durability = typeof Durability[keyof typeof Durability];
+/** Whether a topic may add and delete partitions after create. */
+export declare const PartitionResizePolicy: {
+    readonly Mutable: "mutable";
+    readonly Fixed: "fixed";
+};
+export type PartitionResizePolicy = typeof PartitionResizePolicy[keyof typeof PartitionResizePolicy];
 export {};
 //# sourceMappingURL=topic.utils.d.ts.map

package/dist/wire/topic/topic.utils.js

@@ -14,8 +14,11 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
+import { deserializePartitionContext, PARTITION_CONTEXT_SIZE } from '../vsr/header.js';
 import { toDate } from '../serialize.utils.js';
 import { deserializePrefixedOptions } from '../options.utils.js';
+/** Default of `message_expiry` and `max_topic_size`: never expire, no cap. */
+const UNLIMITED = 0xffffffffffffffffn;
 /**
  * Compression algorithm options.
  */
@@ -41,8 +44,8 @@ export const isValidCompressionAlgorithm = (ca) => Object.values(CompressionAlgo
 export const compressionAlgorithmName = (ca) => ca === CompressionAlgorithm.Gzip ? 'gzip' : 'none';
 /**
  * Deserializes a topic header from a buffer.
- * Layout: 50 fixed bytes, name, then two length-prefixed options blocks
- * (client-explicit and server-derived).
+ * Layout: 33 fixed bytes, name, then two length-prefixed options blocks
+ * (client-explicit and server-derived) holding every setting.
  *
  * @param p - Buffer containing serialized topic data
  * @param pos - Starting position in the buffer
@@ -53,18 +56,24 @@ export const deserializeBaseTopic = (p, pos = 0) => {
     const id = p.readUInt32LE(pos);
     const createdAt = toDate(p.readBigUint64LE(pos + 4));
     const partitionsCount = p.readUInt32LE(pos + 12);
-    const messageExpiry = p.readBigUInt64LE(pos + 16);
-    const compressionAlgorithm = p.readUInt8(pos + 24);
-    const maxTopicSize = p.readBigUInt64LE(pos + 25);
-    const sizeBytes = p.readBigUInt64LE(pos + 33);
-    const messagesCount = p.readBigUInt64LE(pos + 41);
-    const nameLength = p.readUInt8(pos + 49);
-    const name = p.subarray(pos + 50, pos + 50 + nameLength).toString();
-    pos += 50 + nameLength;
+    const sizeBytes = p.readBigUInt64LE(pos + 16);
+    const messagesCount = p.readBigUInt64LE(pos + 24);
+    const nameLength = p.readUInt8(pos + 32);
+    const name = p.subarray(pos + 33, pos + 33 + nameLength).toString();
+    pos += 33 + nameLength;
     const explicit = deserializePrefixedOptions(p, pos);
     pos += explicit.bytesRead;
     const derived = deserializePrefixedOptions(p, pos);
     pos += derived.bytesRead;
+    const setting = (key) => explicit.options[key] ?? derived.options[key];
+    const limit = (key) => {
+        const value = setting(key);
+        return typeof value === 'bigint' ? value : UNLIMITED;
+    };
+    const compressionAlgorithm = setting('compression_algorithm') === 'gzip'
+        ? CompressionAlgorithm.Gzip : CompressionAlgorithm.None;
+    const messageExpiry = limit('message_expiry');
+    const maxTopicSize = limit('max_topic_size');
     return {
         bytesRead: pos - start,
         data: {
@@ -91,7 +100,7 @@ export const deserializeBaseTopic = (p, pos = 0) => {
  */
 export const deserializePartition = (p, pos = 0) => {
     return {
-        bytesRead: 4 + 8 + 4 + 8 + 8 + 8,
+        bytesRead: 40 + PARTITION_CONTEXT_SIZE,
         data: {
             id: p.readUInt32LE(pos),
             createdAt: toDate(p.readBigUint64LE(pos + 4)),
@@ -99,6 +108,7 @@ export const deserializePartition = (p, pos = 0) => {
             currentOffset: p.readBigUint64LE(pos + 16),
             sizeBytes: p.readBigUint64LE(pos + 24),
             messagesCount: p.readBigUint64LE(pos + 32),
+            context: deserializePartitionContext(p, pos + 40),
         }
     };
 };
@@ -150,4 +160,9 @@ export const Durability = {
     Replicated: 'replicated',
     Persisted: 'persisted'
 };
+/** Whether a topic may add and delete partitions after create. */
+export const PartitionResizePolicy = {
+    Mutable: 'mutable',
+    Fixed: 'fixed'
+};
 //# sourceMappingURL=topic.utils.js.map

package/dist/wire/topic/topic.utils.test.js

@@ -20,18 +20,15 @@ import { deserializeBaseTopic } from './topic.utils.js';
 import { serializeOptions } from '../options.utils.js';
 import { HeaderValue } from '../message/header.utils.js';
 describe('deserializeBaseTopic', () => {
-    it('uses the 50-byte fixed layout with two options blocks', () => {
-        const fixed = Buffer.alloc(51);
+    it('uses the 33-byte fixed layout with settings in two options blocks', () => {
+        const fixed = Buffer.alloc(34);
         fixed.writeUInt32LE(7, 0);
         fixed.writeBigUInt64LE(1710000000000n, 4);
         fixed.writeUInt32LE(3, 12);
-        fixed.writeBigUInt64LE(86400000000n, 16);
-        fixed.writeUInt8(2, 24);
-        fixed.writeBigUInt64LE(1000000n, 25);
-        fixed.writeBigUInt64LE(4096n, 33);
-        fixed.writeBigUInt64LE(12n, 41);
-        fixed.writeUInt8(1, 49);
-        fixed.write('t', 50);
+        fixed.writeBigUInt64LE(4096n, 16);
+        fixed.writeBigUInt64LE(12n, 24);
+        fixed.writeUInt8(1, 32);
+        fixed.write('t', 33);
         const explicit = serializeOptions([
             { key: 'message_expiry', value: HeaderValue.Uint64(86400000000n) }
         ]);
@@ -61,18 +58,21 @@ describe('deserializeBaseTopic', () => {
             max_topic_size: 1000000n
         });
     });
-    it('skips empty options blocks', () => {
-        const fixed = Buffer.alloc(51);
+    it('skips empty options blocks and falls back to the catalog defaults', () => {
+        const fixed = Buffer.alloc(34);
         fixed.writeUInt32LE(1, 0);
         fixed.writeUInt32LE(2, 12);
-        fixed.writeUInt8(1, 49);
-        fixed.write('t', 50);
+        fixed.writeUInt8(1, 32);
+        fixed.write('t', 33);
         const data = Buffer.concat([fixed, Buffer.alloc(8)]);
         const { bytesRead, data: topic } = deserializeBaseTopic(data);
         assert.equal(bytesRead, data.length);
         assert.equal(topic.partitionsCount, 2);
         assert.deepEqual(topic.options, {});
         assert.deepEqual(topic.derivedOptions, {});
+        assert.equal(topic.compressionAlgorithm, 1);
+        assert.equal(topic.messageExpiry, 0xffffffffffffffffn);
+        assert.equal(topic.maxTopicSize, 0xffffffffffffffffn);
     });
 });
 //# sourceMappingURL=topic.utils.test.js.map

package/dist/wire/topic/update-topic.command.d.ts

@@ -1,8 +1,8 @@
-import { type Id } from '../identifier.utils.js';
-import { type OptionEntry } from '../options.utils.js';
-import { type CompressionAlgorithm as CompressionAlgorithmT } from './topic.utils.js';
+import type { Id } from '../identifier.utils.js';
+import type { OptionEntry, TopicOptionKey } from '../options.utils.js';
 /**
- * Parameters for the update topic command.
+ * Parameters for the update topic command. Keys left out keep their values.
+ * Settings fixed at create, compression among them, have no field here.
  */
 export type UpdateTopic = {
     /** Stream identifier (ID or name) */
@@ -10,34 +10,41 @@ export type UpdateTopic = {
     /** Topic identifier (ID or name) */
     topicId: Id;
     /** New topic name (1-255 bytes) */
-    name: string;
-    /** Compression algorithm (None or Gzip) */
-    compressionAlgorithm?: CompressionAlgorithmT;
+    name?: string;
     /**
      * Message expiry time in microseconds. `0n` is not "unlimited": it omits the
-     * key, so the topic keeps whatever expiry it currently has. Resetting a key
-     * back to the server default is not expressible on an update.
+     * key, so the topic keeps whatever expiry it currently has. Reset the key to
+     * return to the server default.
      */
     messageExpiry?: bigint;
     /**
      * Maximum topic size in bytes. `0n` is not "unlimited": it omits the key, so
-     * the topic keeps whatever cap it currently has. Resetting a key back to the
-     * server default is not expressible on an update.
+     * the topic keeps whatever cap it currently has. Reset the key to return to
+     * the server default.
      */
     maxTopicSize?: bigint;
+    /** Keys to reset to their defaults: `message_expiry` or `max_topic_size` */
+    reset?: TopicOptionKey[];
     /**
-     * Option keys with no field of their own. The server refuses any key an update
-     * may not change, by name; a key left out keeps its current value.
+     * Reset names with no typed member, for a resettable key the server catalog
+     * gained after this build shipped. The server decides on them.
+     */
+    rawReset?: readonly string[];
+    /**
+     * Option keys with no field of their own, for an updatable key the server
+     * catalog gained after this build shipped. A field above wins on collision.
+     * The server decides on them, so a create-only or unknown key comes back as
+     * a server error.
      */
     options?: OptionEntry[];
 };
 /**
  * Update topic command definition.
- * Updates a topic's configuration.
+ * Changes only the keys it names, through the generic update command.
  */
 export declare const UPDATE_TOPIC: {
     code: number;
-    serialize: ({ streamId, topicId, name, compressionAlgorithm, messageExpiry, maxTopicSize, options: extraOptions }: UpdateTopic) => Buffer<ArrayBuffer>;
+    serialize: ({ streamId, topicId, name, messageExpiry, maxTopicSize, reset, rawReset, options: rawOptions }: UpdateTopic) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
 /**

package/dist/wire/topic/update-topic.command.js

@@ -14,36 +14,20 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-import { serializeIdentifier } from '../identifier.utils.js';
-import { dedupeOptions, serializeOptions } from '../options.utils.js';
 import { HeaderValue } from '../message/header.utils.js';
-import { deserializeVoidResponse } from '../../client/client.utils.js';
 import { wrapCommand } from '../command.utils.js';
-import { COMMAND_CODE } from '../command.code.js';
-import { CompressionAlgorithm, compressionAlgorithmName, isValidCompressionAlgorithm } from './topic.utils.js';
+import { OptionsScope } from '../system/describe-options.command.js';
+import { UPDATE_RESOURCE, columnOption } from '../system/update-resource.command.js';
 /**
  * Update topic command definition.
- * Updates a topic's configuration.
+ * Changes only the keys it names, through the generic update command.
  */
 export const UPDATE_TOPIC = {
-    code: COMMAND_CODE.UpdateTopic,
-    serialize: ({ streamId, topicId, name, compressionAlgorithm = CompressionAlgorithm.None, messageExpiry = 0n, maxTopicSize = 0n, options: extraOptions = [] }) => {
-        const streamIdentifier = serializeIdentifier(streamId);
-        const topicIdentifier = serializeIdentifier(topicId);
-        const bName = Buffer.from(name);
-        if (bName.length < 1 || bName.length > 255)
-            throw new Error('Topic name should be between 1 and 255 bytes');
-        if (!isValidCompressionAlgorithm(compressionAlgorithm))
-            throw new Error(`updateTopic: invalid compressionAlgorithm (${compressionAlgorithm})`);
-        // Settings ride the options block. A default value means the caller did not
-        // set the key, so it is omitted and the server leaves the current value be.
-        // Caller keys first so a typed field below overwrites one of them.
-        const options = [...extraOptions];
-        if (compressionAlgorithm !== CompressionAlgorithm.None)
-            options.push({
-                key: 'compression_algorithm',
-                value: HeaderValue.String(compressionAlgorithmName(compressionAlgorithm))
-            });
+    code: UPDATE_RESOURCE.code,
+    serialize: ({ streamId, topicId, name, messageExpiry = 0n, maxTopicSize = 0n, reset, rawReset, options: rawOptions }) => {
+        const options = [];
+        if (name !== undefined)
+            options.push(columnOption('name', name));
         if (messageExpiry !== 0n)
             options.push({
                 key: 'message_expiry',
@@ -54,17 +38,11 @@ export const UPDATE_TOPIC = {
                 key: 'max_topic_size',
                 value: HeaderValue.Uint64(maxTopicSize)
             });
-        const b = Buffer.allocUnsafe(1);
-        b.writeUInt8(bName.length, 0);
-        return Buffer.concat([
-            streamIdentifier,
-            topicIdentifier,
-            b,
-            bName,
-            serializeOptions(dedupeOptions(options)),
-        ]);
+        return UPDATE_RESOURCE.serialize({
+            target: { scope: OptionsScope.Topic, streamId, topicId }, options, reset, rawOptions, rawReset
+        });
     },
-    deserialize: deserializeVoidResponse
+    deserialize: UPDATE_RESOURCE.deserialize
 };
 /**
  * Executable update topic command function.

package/dist/wire/user/create-user.command.d.ts

@@ -1,6 +1,15 @@
 import type { CommandResponse } from '../../client/client.type.js';
 import { type User, type UserStatus } from './user.utils.js';
 import { type UserPermissions } from './permissions.utils.js';
+import { type OptionEntry } from '../options.utils.js';
+/**
+ * Options a user takes at create. The server catalog has no user key yet, so
+ * only keys newer than this build can ride here.
+ */
+export type UserOptions = {
+    /** Option keys with no field of their own */
+    options?: OptionEntry[];
+};
 /**
  * Parameters for the create user command.
  */
@@ -13,14 +22,15 @@ export type CreateUser = {
     status: UserStatus;
     /** Optional user permissions */
     permissions?: UserPermissions;
-};
+} & UserOptions;
 /**
  * Create user command definition.
  * Creates a new user with the specified credentials and permissions.
+ * The options block runs to the end of the payload.
  */
 export declare const CREATE_USER: {
     code: number;
-    serialize: ({ username, password, status, permissions }: CreateUser) => Buffer<ArrayBuffer>;
+    serialize: ({ username, password, status, permissions, options }: CreateUser) => Buffer<ArrayBuffer>;
     deserialize: (r: CommandResponse) => User;
 };
 /**

package/dist/wire/user/create-user.command.js

@@ -19,13 +19,15 @@ import { COMMAND_CODE } from '../command.code.js';
 import { deserializeUser } from './user.utils.js';
 import { uint8ToBuf, uint32ToBuf, boolToBuf } from '../number.utils.js';
 import { serializePermissions } from './permissions.utils.js';
+import { dedupeOptions, serializeOptions, sortOptions } from '../options.utils.js';
 /**
  * Create user command definition.
  * Creates a new user with the specified credentials and permissions.
+ * The options block runs to the end of the payload.
  */
 export const CREATE_USER = {
     code: COMMAND_CODE.CreateUser,
-    serialize: ({ username, password, status, permissions }) => {
+    serialize: ({ username, password, status, permissions, options = [] }) => {
         const bUsername = Buffer.from(username);
         const bPassword = Buffer.from(password);
         if (bUsername.length < 1 || bUsername.length > 255)
@@ -39,14 +41,16 @@ export const CREATE_USER = {
             bPassword,
             uint8ToBuf(status),
         ]);
+        const bOptions = serializeOptions(sortOptions(dedupeOptions(options)));
         if (!permissions)
-            return Buffer.concat([bUser, boolToBuf(false)]);
+            return Buffer.concat([bUser, boolToBuf(false), bOptions]);
         const bPermissions = serializePermissions(permissions);
         return Buffer.concat([
             bUser,
             boolToBuf(true),
             uint32ToBuf(bPermissions.length),
-            bPermissions
+            bPermissions,
+            bOptions
         ]);
     },
     deserialize: (r) => deserializeUser(r.data)

package/dist/wire/user/index.d.ts

@@ -5,4 +5,5 @@ export * from './get-user.command.js';
 export * from './get-users.command.js';
 export * from './update-permissions.command.js';
 export * from './update-user.command.js';
+export { UserStatus } from './user.utils.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/wire/user/index.js

@@ -21,4 +21,5 @@ export * from './get-user.command.js';
 export * from './get-users.command.js';
 export * from './update-permissions.command.js';
 export * from './update-user.command.js';
+export { UserStatus } from './user.utils.js';
 //# sourceMappingURL=index.js.map

package/dist/wire/user/update-user.command.d.ts

@@ -1,23 +1,41 @@
-import type { UserStatus } from './user.utils.js';
-import { type Id } from '../identifier.utils.js';
+import type { Id } from '../identifier.utils.js';
+import type { OptionEntry, UserOptionKey } from '../options.utils.js';
+import { UserStatus } from './user.utils.js';
 /**
- * Parameters for the update user command.
+ * Parameters for the update user command. Keys left out keep their values.
  */
 export type UpdateUser = {
     /** User identifier (ID or username) */
     userId: Id;
-    /** Optional new username (1-255 bytes) */
+    /** Optional new username (3-50 bytes) */
     username?: string;
-    /** Optional new status */
+    /** Optional new status. Deactivating a user ends its sessions. */
     status?: UserStatus;
+    /**
+     * Keys to reset to their defaults. No user key is resettable yet, so any key
+     * is refused before the request is sent.
+     */
+    reset?: UserOptionKey[];
+    /**
+     * Reset names with no typed member, for a resettable key the server catalog
+     * gained after this build shipped. The server decides on them.
+     */
+    rawReset?: readonly string[];
+    /**
+     * Option keys with no field of their own, for an updatable key the server
+     * catalog gained after this build shipped. A field above wins on collision.
+     * The server decides on them, so a create-only or unknown key comes back as
+     * a server error.
+     */
+    options?: OptionEntry[];
 };
 /**
  * Update user command definition.
- * Updates a user's username and/or status.
+ * Changes only the keys it names, through the generic update command.
  */
 export declare const UPDATE_USER: {
     code: number;
-    serialize: ({ userId, username, status }: UpdateUser) => Buffer<ArrayBuffer>;
+    serialize: ({ userId, username, status, reset, rawReset, options: rawOptions }: UpdateUser) => Buffer<ArrayBuffer>;
     deserialize: (r: import("../../index.js").CommandResponse) => boolean;
 };
 /**

package/dist/wire/user/update-user.command.js

@@ -15,42 +15,29 @@
 // specific language governing permissions and limitations
 // under the License.
 import { wrapCommand } from '../command.utils.js';
-import { COMMAND_CODE } from '../command.code.js';
-import { deserializeVoidResponse } from '../../client/client.utils.js';
-import { serializeIdentifier } from '../identifier.utils.js';
-import { uint8ToBuf } from '../number.utils.js';
+import { HeaderValue } from '../message/header.utils.js';
+import { OptionsScope } from '../system/describe-options.command.js';
+import { UPDATE_RESOURCE, columnOption } from '../system/update-resource.command.js';
+import { UserStatus } from './user.utils.js';
 /**
  * Update user command definition.
- * Updates a user's username and/or status.
+ * Changes only the keys it names, through the generic update command.
  */
 export const UPDATE_USER = {
-    code: COMMAND_CODE.UpdateUser,
-    serialize: ({ userId, username, status }) => {
-        const bId = serializeIdentifier(userId);
-        let bUsername, bStatus;
-        if (username) {
-            const bn = Buffer.from(username);
-            if (bn.length < 1 || bn.length > 255)
-                throw new Error('User username should be between 1 and 255 bytes');
-            bUsername = Buffer.concat([
-                uint8ToBuf(1),
-                uint8ToBuf(bn.length),
-                bn
-            ]);
-        }
-        else
-            bUsername = uint8ToBuf(0);
-        if (status)
-            bStatus = Buffer.concat([uint8ToBuf(1), uint8ToBuf(status)]);
-        else
-            bStatus = uint8ToBuf(0);
-        return Buffer.concat([
-            bId,
-            bUsername,
-            bStatus,
-        ]);
+    code: UPDATE_RESOURCE.code,
+    serialize: ({ userId, username, status, reset, rawReset, options: rawOptions }) => {
+        const options = [];
+        if (username !== undefined)
+            options.push(columnOption('username', username));
+        if (status !== undefined)
+            options.push(status === UserStatus.Active || status === UserStatus.Inactive
+                ? { key: 'status', value: HeaderValue.String(status === UserStatus.Active ? 'active' : 'inactive') }
+                : { key: 'status', value: HeaderValue.Bool(false) });
+        return UPDATE_RESOURCE.serialize({
+            target: { scope: OptionsScope.User, userId }, options, reset, rawOptions, rawReset
+        });
     },
-    deserialize: deserializeVoidResponse
+    deserialize: UPDATE_RESOURCE.deserialize
 };
 /**
  * Executable update user command function.

package/dist/wire/user/user.utils.d.ts

@@ -14,6 +14,8 @@ export type BaseUser = {
     userName: string;
     /** Options the client explicitly sent at create */
     options: ParsedOptions;
+    /** Options the server filled */
+    derivedOptions: ParsedOptions;
 };
 /**
  * Result of deserializing a base user.

package/dist/wire/user/user.utils.js

@@ -58,15 +58,17 @@ export const deserializeBaseUser = (p, pos = 0) => {
     const status = statusString(p.readUInt8(pos + 12));
     const userNameLength = p.readUInt8(pos + 13);
     const userName = p.subarray(pos + 14, pos + 14 + userNameLength).toString();
-    const { bytesRead: optionsBytes, options } = deserializePrefixedOptions(p, pos + 14 + userNameLength);
+    const explicit = deserializePrefixedOptions(p, pos + 14 + userNameLength);
+    const derived = deserializePrefixedOptions(p, pos + 14 + userNameLength + explicit.bytesRead);
     return {
-        bytesRead: 14 + userNameLength + optionsBytes,
+        bytesRead: 14 + userNameLength + explicit.bytesRead + derived.bytesRead,
         data: {
             id,
             createdAt,
             status,
             userName,
-            options,
+            options: explicit.options,
+            derivedOptions: derived.options,
         }
     };
 };

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

@@ -20,20 +20,32 @@ export declare const REQUEST_OFFSET: {
     readonly size: 48;
     readonly command: 60;
     readonly client: 128;
+    readonly requestChecksum: 144;
     readonly timestamp: 160;
     readonly request: 168;
     readonly operation: 176;
     readonly session: 184;
     readonly reserved: 196;
+    readonly partitionIncarnation: 200;
+    readonly ownerGeneration: 208;
+    readonly minimumMetadataOp: 216;
 };
 /** `ReplyHeader` field offsets the client reads. */
 export declare const REPLY_OFFSET: {
     readonly size: 48;
     readonly command: 60;
+    readonly requestChecksum: 128;
+    readonly client: 160;
+    readonly op: 176;
     readonly commit: 184;
+    readonly request: 200;
     readonly operation: 208;
     readonly status: 216;
+    readonly reserved: 220;
+    readonly partitionIncarnation: 224;
 };
+export declare const COMMITTED_RESULT_MARKER = 1;
+export declare const hasCommittedResult: (header: Buffer) => boolean;
 /** `EvictionHeader` field offsets the client reads. */
 export declare const EVICTION_OFFSET: {
     readonly command: 60;
@@ -70,8 +82,17 @@ export declare const EvictionReason: {
     readonly IncompatibleProtocol: 14;
     readonly MalformedLogin: 15;
 };
+export declare const PARTITION_CONTEXT_SIZE = 24;
+export type PartitionContext = {
+    readonly incarnation: bigint;
+    readonly ownerGeneration: bigint;
+    readonly metadataOp: bigint;
+};
+export declare const EMPTY_PARTITION_CONTEXT: PartitionContext;
+export declare const deserializePartitionContext: (data: Buffer, offset?: number) => PartitionContext;
 /** Fields the client writes into a request header. */
 export type RequestHeaderFields = {
+    context?: PartitionContext;
     /** Header + body total, bytes. */
     size: number;
     /** Ephemeral client identifier (u128). */
@@ -85,13 +106,7 @@ export type RequestHeaderFields = {
     /** Command code for `NonReplicated`, placed in `reserved[0..4]`. */
     nonReplicatedCode?: number;
 };
-/**
- * Encodes a 256-byte request header. Only the six fields the server reads
- * are written. The checksums stay zero: the frame and body checksums are not
- * read on the client request path, and `request_checksum` treats zero as
- * unstamped, which opts out of the server's payload comparison. Stamping it is
- * optional -- the Rust SDK does for deduped ops, this SDK does not yet.
- */
+/** Encodes one request identity and its captured partition context. */
 export declare const encodeRequestHeader: (fields: RequestHeaderFields) => Buffer;
 /**
  * Reads the frame discriminant. `command` sits at the same offset in every
@@ -100,7 +115,7 @@ export declare const encodeRequestHeader: (fields: RequestHeaderFields) => Buffe
 export declare const peekCommand: (header: Buffer) => number;
 /** Reads the total frame size from a reply or eviction header. */
 export declare const readSize: (header: Buffer) => number;
-/** Reads the pre-commit denial status; 0 means the reply committed. */
+/** Reads the pre-commit denial status; zero alone does not prove commit. */
 export declare const readStatus: (header: Buffer) => number;
 /** Reads the `Operation` discriminant from a reply header. */
 export declare const readReplyOperation: (header: Buffer) => number;