rivetkit 2.0.39 → 2.0.41

package/dist/schemas/client-protocol/v1.js

@@ -0,0 +1,301 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+export function readInit(bc) {
+    return {
+        actorId: bare.readString(bc),
+        connectionId: bare.readString(bc),
+        connectionToken: bare.readString(bc),
+    };
+}
+export function writeInit(bc, x) {
+    bare.writeString(bc, x.actorId);
+    bare.writeString(bc, x.connectionId);
+    bare.writeString(bc, x.connectionToken);
+}
+function read0(bc) {
+    return bare.readBool(bc)
+        ? bare.readData(bc)
+        : null;
+}
+function write0(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeData(bc, x);
+    }
+}
+function read1(bc) {
+    return bare.readBool(bc)
+        ? bare.readUint(bc)
+        : null;
+}
+function write1(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeUint(bc, x);
+    }
+}
+export function readError(bc) {
+    return {
+        group: bare.readString(bc),
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+        metadata: read0(bc),
+        actionId: read1(bc),
+    };
+}
+export function writeError(bc, x) {
+    bare.writeString(bc, x.group);
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+    write0(bc, x.metadata);
+    write1(bc, x.actionId);
+}
+export function readActionResponse(bc) {
+    return {
+        id: bare.readUint(bc),
+        output: bare.readData(bc),
+    };
+}
+export function writeActionResponse(bc, x) {
+    bare.writeUint(bc, x.id);
+    bare.writeData(bc, x.output);
+}
+export function readEvent(bc) {
+    return {
+        name: bare.readString(bc),
+        args: bare.readData(bc),
+    };
+}
+export function writeEvent(bc, x) {
+    bare.writeString(bc, x.name);
+    bare.writeData(bc, x.args);
+}
+export function readToClientBody(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "Init", val: readInit(bc) };
+        case 1:
+            return { tag: "Error", val: readError(bc) };
+        case 2:
+            return { tag: "ActionResponse", val: readActionResponse(bc) };
+        case 3:
+            return { tag: "Event", val: readEvent(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeToClientBody(bc, x) {
+    switch (x.tag) {
+        case "Init": {
+            bare.writeU8(bc, 0);
+            writeInit(bc, x.val);
+            break;
+        }
+        case "Error": {
+            bare.writeU8(bc, 1);
+            writeError(bc, x.val);
+            break;
+        }
+        case "ActionResponse": {
+            bare.writeU8(bc, 2);
+            writeActionResponse(bc, x.val);
+            break;
+        }
+        case "Event": {
+            bare.writeU8(bc, 3);
+            writeEvent(bc, x.val);
+            break;
+        }
+    }
+}
+export function readToClient(bc) {
+    return {
+        body: readToClientBody(bc),
+    };
+}
+export function writeToClient(bc, x) {
+    writeToClientBody(bc, x.body);
+}
+export function encodeToClient(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeToClient(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeToClient(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readToClient(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readActionRequest(bc) {
+    return {
+        id: bare.readUint(bc),
+        name: bare.readString(bc),
+        args: bare.readData(bc),
+    };
+}
+export function writeActionRequest(bc, x) {
+    bare.writeUint(bc, x.id);
+    bare.writeString(bc, x.name);
+    bare.writeData(bc, x.args);
+}
+export function readSubscriptionRequest(bc) {
+    return {
+        eventName: bare.readString(bc),
+        subscribe: bare.readBool(bc),
+    };
+}
+export function writeSubscriptionRequest(bc, x) {
+    bare.writeString(bc, x.eventName);
+    bare.writeBool(bc, x.subscribe);
+}
+export function readToServerBody(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "ActionRequest", val: readActionRequest(bc) };
+        case 1:
+            return { tag: "SubscriptionRequest", val: readSubscriptionRequest(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeToServerBody(bc, x) {
+    switch (x.tag) {
+        case "ActionRequest": {
+            bare.writeU8(bc, 0);
+            writeActionRequest(bc, x.val);
+            break;
+        }
+        case "SubscriptionRequest": {
+            bare.writeU8(bc, 1);
+            writeSubscriptionRequest(bc, x.val);
+            break;
+        }
+    }
+}
+export function readToServer(bc) {
+    return {
+        body: readToServerBody(bc),
+    };
+}
+export function writeToServer(bc, x) {
+    writeToServerBody(bc, x.body);
+}
+export function encodeToServer(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeToServer(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeToServer(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readToServer(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpActionRequest(bc) {
+    return {
+        args: bare.readData(bc),
+    };
+}
+export function writeHttpActionRequest(bc, x) {
+    bare.writeData(bc, x.args);
+}
+export function encodeHttpActionRequest(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpActionRequest(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpActionRequest(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpActionRequest(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpActionResponse(bc) {
+    return {
+        output: bare.readData(bc),
+    };
+}
+export function writeHttpActionResponse(bc, x) {
+    bare.writeData(bc, x.output);
+}
+export function encodeHttpActionResponse(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpActionResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpActionResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpActionResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpResponseError(bc) {
+    return {
+        group: bare.readString(bc),
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+        metadata: read0(bc),
+    };
+}
+export function writeHttpResponseError(bc, x) {
+    bare.writeString(bc, x.group);
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+    write0(bc, x.metadata);
+}
+export function encodeHttpResponseError(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpResponseError(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpResponseError(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpResponseError(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpResolveResponse(bc) {
+    return {
+        actorId: bare.readString(bc),
+    };
+}
+export function writeHttpResolveResponse(bc, x) {
+    bare.writeString(bc, x.actorId);
+}
+export function encodeHttpResolveResponse(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpResolveResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpResolveResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpResolveResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message ?? "Assertion failed");
+}

package/dist/schemas/client-protocol/v2.js

@@ -0,0 +1,299 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+export function readInit(bc) {
+    return {
+        actorId: bare.readString(bc),
+        connectionId: bare.readString(bc),
+    };
+}
+export function writeInit(bc, x) {
+    bare.writeString(bc, x.actorId);
+    bare.writeString(bc, x.connectionId);
+}
+function read0(bc) {
+    return bare.readBool(bc)
+        ? bare.readData(bc)
+        : null;
+}
+function write0(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeData(bc, x);
+    }
+}
+function read1(bc) {
+    return bare.readBool(bc)
+        ? bare.readUint(bc)
+        : null;
+}
+function write1(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeUint(bc, x);
+    }
+}
+export function readError(bc) {
+    return {
+        group: bare.readString(bc),
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+        metadata: read0(bc),
+        actionId: read1(bc),
+    };
+}
+export function writeError(bc, x) {
+    bare.writeString(bc, x.group);
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+    write0(bc, x.metadata);
+    write1(bc, x.actionId);
+}
+export function readActionResponse(bc) {
+    return {
+        id: bare.readUint(bc),
+        output: bare.readData(bc),
+    };
+}
+export function writeActionResponse(bc, x) {
+    bare.writeUint(bc, x.id);
+    bare.writeData(bc, x.output);
+}
+export function readEvent(bc) {
+    return {
+        name: bare.readString(bc),
+        args: bare.readData(bc),
+    };
+}
+export function writeEvent(bc, x) {
+    bare.writeString(bc, x.name);
+    bare.writeData(bc, x.args);
+}
+export function readToClientBody(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "Init", val: readInit(bc) };
+        case 1:
+            return { tag: "Error", val: readError(bc) };
+        case 2:
+            return { tag: "ActionResponse", val: readActionResponse(bc) };
+        case 3:
+            return { tag: "Event", val: readEvent(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeToClientBody(bc, x) {
+    switch (x.tag) {
+        case "Init": {
+            bare.writeU8(bc, 0);
+            writeInit(bc, x.val);
+            break;
+        }
+        case "Error": {
+            bare.writeU8(bc, 1);
+            writeError(bc, x.val);
+            break;
+        }
+        case "ActionResponse": {
+            bare.writeU8(bc, 2);
+            writeActionResponse(bc, x.val);
+            break;
+        }
+        case "Event": {
+            bare.writeU8(bc, 3);
+            writeEvent(bc, x.val);
+            break;
+        }
+    }
+}
+export function readToClient(bc) {
+    return {
+        body: readToClientBody(bc),
+    };
+}
+export function writeToClient(bc, x) {
+    writeToClientBody(bc, x.body);
+}
+export function encodeToClient(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeToClient(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeToClient(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readToClient(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readActionRequest(bc) {
+    return {
+        id: bare.readUint(bc),
+        name: bare.readString(bc),
+        args: bare.readData(bc),
+    };
+}
+export function writeActionRequest(bc, x) {
+    bare.writeUint(bc, x.id);
+    bare.writeString(bc, x.name);
+    bare.writeData(bc, x.args);
+}
+export function readSubscriptionRequest(bc) {
+    return {
+        eventName: bare.readString(bc),
+        subscribe: bare.readBool(bc),
+    };
+}
+export function writeSubscriptionRequest(bc, x) {
+    bare.writeString(bc, x.eventName);
+    bare.writeBool(bc, x.subscribe);
+}
+export function readToServerBody(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "ActionRequest", val: readActionRequest(bc) };
+        case 1:
+            return { tag: "SubscriptionRequest", val: readSubscriptionRequest(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writeToServerBody(bc, x) {
+    switch (x.tag) {
+        case "ActionRequest": {
+            bare.writeU8(bc, 0);
+            writeActionRequest(bc, x.val);
+            break;
+        }
+        case "SubscriptionRequest": {
+            bare.writeU8(bc, 1);
+            writeSubscriptionRequest(bc, x.val);
+            break;
+        }
+    }
+}
+export function readToServer(bc) {
+    return {
+        body: readToServerBody(bc),
+    };
+}
+export function writeToServer(bc, x) {
+    writeToServerBody(bc, x.body);
+}
+export function encodeToServer(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeToServer(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeToServer(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readToServer(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpActionRequest(bc) {
+    return {
+        args: bare.readData(bc),
+    };
+}
+export function writeHttpActionRequest(bc, x) {
+    bare.writeData(bc, x.args);
+}
+export function encodeHttpActionRequest(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpActionRequest(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpActionRequest(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpActionRequest(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpActionResponse(bc) {
+    return {
+        output: bare.readData(bc),
+    };
+}
+export function writeHttpActionResponse(bc, x) {
+    bare.writeData(bc, x.output);
+}
+export function encodeHttpActionResponse(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpActionResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpActionResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpActionResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpResponseError(bc) {
+    return {
+        group: bare.readString(bc),
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+        metadata: read0(bc),
+    };
+}
+export function writeHttpResponseError(bc, x) {
+    bare.writeString(bc, x.group);
+    bare.writeString(bc, x.code);
+    bare.writeString(bc, x.message);
+    write0(bc, x.metadata);
+}
+export function encodeHttpResponseError(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpResponseError(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpResponseError(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpResponseError(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readHttpResolveResponse(bc) {
+    return {
+        actorId: bare.readString(bc),
+    };
+}
+export function writeHttpResolveResponse(bc, x) {
+    bare.writeString(bc, x.actorId);
+}
+export function encodeHttpResolveResponse(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeHttpResolveResponse(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeHttpResolveResponse(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readHttpResolveResponse(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message ?? "Assertion failed");
+}

package/dist/schemas/file-system-driver/v1.js

@@ -0,0 +1,76 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+function read0(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [bare.readString(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc);
+    }
+    return result;
+}
+function write0(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i]);
+    }
+}
+export function readActorState(bc) {
+    return {
+        actorId: bare.readString(bc),
+        name: bare.readString(bc),
+        key: read0(bc),
+        persistedData: bare.readData(bc),
+        createdAt: bare.readU64(bc),
+    };
+}
+export function writeActorState(bc, x) {
+    bare.writeString(bc, x.actorId);
+    bare.writeString(bc, x.name);
+    write0(bc, x.key);
+    bare.writeData(bc, x.persistedData);
+    bare.writeU64(bc, x.createdAt);
+}
+export function encodeActorState(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeActorState(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeActorState(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readActorState(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readActorAlarm(bc) {
+    return {
+        actorId: bare.readString(bc),
+        timestamp: bare.readUint(bc),
+    };
+}
+export function writeActorAlarm(bc, x) {
+    bare.writeString(bc, x.actorId);
+    bare.writeUint(bc, x.timestamp);
+}
+export function encodeActorAlarm(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeActorAlarm(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeActorAlarm(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readActorAlarm(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message ?? "Assertion failed");
+}