rivetkit 2.0.39 → 2.0.41

package/dist/schemas/actor-persist/v1.js

@@ -0,0 +1,167 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+export function readPersistedSubscription(bc) {
+    return {
+        eventName: bare.readString(bc),
+    };
+}
+export function writePersistedSubscription(bc, x) {
+    bare.writeString(bc, x.eventName);
+}
+function read0(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedSubscription(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedSubscription(bc);
+    }
+    return result;
+}
+function write0(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedSubscription(bc, x[i]);
+    }
+}
+export function readPersistedConnection(bc) {
+    return {
+        id: bare.readString(bc),
+        token: bare.readString(bc),
+        parameters: bare.readData(bc),
+        state: bare.readData(bc),
+        subscriptions: read0(bc),
+        lastSeen: bare.readU64(bc),
+    };
+}
+export function writePersistedConnection(bc, x) {
+    bare.writeString(bc, x.id);
+    bare.writeString(bc, x.token);
+    bare.writeData(bc, x.parameters);
+    bare.writeData(bc, x.state);
+    write0(bc, x.subscriptions);
+    bare.writeU64(bc, x.lastSeen);
+}
+function read1(bc) {
+    return bare.readBool(bc)
+        ? bare.readData(bc)
+        : null;
+}
+function write1(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeData(bc, x);
+    }
+}
+export function readGenericPersistedScheduleEvent(bc) {
+    return {
+        action: bare.readString(bc),
+        args: read1(bc),
+    };
+}
+export function writeGenericPersistedScheduleEvent(bc, x) {
+    bare.writeString(bc, x.action);
+    write1(bc, x.args);
+}
+export function readPersistedScheduleEventKind(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writePersistedScheduleEventKind(bc, x) {
+    switch (x.tag) {
+        case "GenericPersistedScheduleEvent": {
+            bare.writeU8(bc, 0);
+            writeGenericPersistedScheduleEvent(bc, x.val);
+            break;
+        }
+    }
+}
+export function readPersistedScheduleEvent(bc) {
+    return {
+        eventId: bare.readString(bc),
+        timestamp: bare.readU64(bc),
+        kind: readPersistedScheduleEventKind(bc),
+    };
+}
+export function writePersistedScheduleEvent(bc, x) {
+    bare.writeString(bc, x.eventId);
+    bare.writeU64(bc, x.timestamp);
+    writePersistedScheduleEventKind(bc, x.kind);
+}
+function read2(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedConnection(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedConnection(bc);
+    }
+    return result;
+}
+function write2(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedConnection(bc, x[i]);
+    }
+}
+function read3(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedScheduleEvent(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedScheduleEvent(bc);
+    }
+    return result;
+}
+function write3(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedScheduleEvent(bc, x[i]);
+    }
+}
+export function readPersistedActor(bc) {
+    return {
+        input: read1(bc),
+        hasInitialized: bare.readBool(bc),
+        state: bare.readData(bc),
+        connections: read2(bc),
+        scheduledEvents: read3(bc),
+    };
+}
+export function writePersistedActor(bc, x) {
+    write1(bc, x.input);
+    bare.writeBool(bc, x.hasInitialized);
+    bare.writeData(bc, x.state);
+    write2(bc, x.connections);
+    write3(bc, x.scheduledEvents);
+}
+export function encodePersistedActor(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writePersistedActor(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodePersistedActor(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readPersistedActor(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/actor-persist/v2.js

@@ -0,0 +1,200 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+export function readPersistedSubscription(bc) {
+    return {
+        eventName: bare.readString(bc),
+    };
+}
+export function writePersistedSubscription(bc, x) {
+    bare.writeString(bc, x.eventName);
+}
+function read0(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedSubscription(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedSubscription(bc);
+    }
+    return result;
+}
+function write0(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedSubscription(bc, x[i]);
+    }
+}
+function read1(bc) {
+    return bare.readBool(bc)
+        ? bare.readData(bc)
+        : null;
+}
+function write1(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        bare.writeData(bc, x);
+    }
+}
+export function readPersistedConnection(bc) {
+    return {
+        id: bare.readString(bc),
+        token: bare.readString(bc),
+        parameters: bare.readData(bc),
+        state: bare.readData(bc),
+        subscriptions: read0(bc),
+        lastSeen: bare.readI64(bc),
+        hibernatableRequestId: read1(bc),
+    };
+}
+export function writePersistedConnection(bc, x) {
+    bare.writeString(bc, x.id);
+    bare.writeString(bc, x.token);
+    bare.writeData(bc, x.parameters);
+    bare.writeData(bc, x.state);
+    write0(bc, x.subscriptions);
+    bare.writeI64(bc, x.lastSeen);
+    write1(bc, x.hibernatableRequestId);
+}
+export function readGenericPersistedScheduleEvent(bc) {
+    return {
+        action: bare.readString(bc),
+        args: read1(bc),
+    };
+}
+export function writeGenericPersistedScheduleEvent(bc, x) {
+    bare.writeString(bc, x.action);
+    write1(bc, x.args);
+}
+export function readPersistedScheduleEventKind(bc) {
+    const offset = bc.offset;
+    const tag = bare.readU8(bc);
+    switch (tag) {
+        case 0:
+            return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
+        default: {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "invalid tag");
+        }
+    }
+}
+export function writePersistedScheduleEventKind(bc, x) {
+    switch (x.tag) {
+        case "GenericPersistedScheduleEvent": {
+            bare.writeU8(bc, 0);
+            writeGenericPersistedScheduleEvent(bc, x.val);
+            break;
+        }
+    }
+}
+export function readPersistedScheduleEvent(bc) {
+    return {
+        eventId: bare.readString(bc),
+        timestamp: bare.readI64(bc),
+        kind: readPersistedScheduleEventKind(bc),
+    };
+}
+export function writePersistedScheduleEvent(bc, x) {
+    bare.writeString(bc, x.eventId);
+    bare.writeI64(bc, x.timestamp);
+    writePersistedScheduleEventKind(bc, x.kind);
+}
+export function readPersistedHibernatableWebSocket(bc) {
+    return {
+        requestId: bare.readData(bc),
+        lastSeenTimestamp: bare.readI64(bc),
+        msgIndex: bare.readI64(bc),
+    };
+}
+export function writePersistedHibernatableWebSocket(bc, x) {
+    bare.writeData(bc, x.requestId);
+    bare.writeI64(bc, x.lastSeenTimestamp);
+    bare.writeI64(bc, x.msgIndex);
+}
+function read2(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedConnection(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedConnection(bc);
+    }
+    return result;
+}
+function write2(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedConnection(bc, x[i]);
+    }
+}
+function read3(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedScheduleEvent(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedScheduleEvent(bc);
+    }
+    return result;
+}
+function write3(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedScheduleEvent(bc, x[i]);
+    }
+}
+function read4(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readPersistedHibernatableWebSocket(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readPersistedHibernatableWebSocket(bc);
+    }
+    return result;
+}
+function write4(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writePersistedHibernatableWebSocket(bc, x[i]);
+    }
+}
+export function readPersistedActor(bc) {
+    return {
+        input: read1(bc),
+        hasInitialized: bare.readBool(bc),
+        state: bare.readData(bc),
+        connections: read2(bc),
+        scheduledEvents: read3(bc),
+        hibernatableWebSockets: read4(bc),
+    };
+}
+export function writePersistedActor(bc, x) {
+    write1(bc, x.input);
+    bare.writeBool(bc, x.hasInitialized);
+    bare.writeData(bc, x.state);
+    write2(bc, x.connections);
+    write3(bc, x.scheduledEvents);
+    write4(bc, x.hibernatableWebSockets);
+}
+export function encodePersistedActor(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writePersistedActor(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodePersistedActor(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readPersistedActor(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/actor-persist/v3.js

@@ -0,0 +1,200 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts";
+const config = /* @__PURE__ */ bare.Config({});
+export function readGatewayId(bc) {
+    return bare.readFixedData(bc, 4);
+}
+export function writeGatewayId(bc, x) {
+    assert(x.byteLength === 4);
+    bare.writeFixedData(bc, x);
+}
+export function readRequestId(bc) {
+    return bare.readFixedData(bc, 4);
+}
+export function writeRequestId(bc, x) {
+    assert(x.byteLength === 4);
+    bare.writeFixedData(bc, x);
+}
+export function readMessageIndex(bc) {
+    return bare.readU16(bc);
+}
+export function writeMessageIndex(bc, x) {
+    bare.writeU16(bc, x);
+}
+export function encodeMessageIndex(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeMessageIndex(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeMessageIndex(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readMessageIndex(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+export function readCbor(bc) {
+    return bare.readData(bc);
+}
+export function writeCbor(bc, x) {
+    bare.writeData(bc, x);
+}
+export function readSubscription(bc) {
+    return {
+        eventName: bare.readString(bc),
+    };
+}
+export function writeSubscription(bc, x) {
+    bare.writeString(bc, x.eventName);
+}
+function read0(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readSubscription(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readSubscription(bc);
+    }
+    return result;
+}
+function write0(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeSubscription(bc, x[i]);
+    }
+}
+function read1(bc) {
+    const len = bare.readUintSafe(bc);
+    const result = new Map();
+    for (let i = 0; i < len; i++) {
+        const offset = bc.offset;
+        const key = bare.readString(bc);
+        if (result.has(key)) {
+            bc.offset = offset;
+            throw new bare.BareError(offset, "duplicated key");
+        }
+        result.set(key, bare.readString(bc));
+    }
+    return result;
+}
+function write1(bc, x) {
+    bare.writeUintSafe(bc, x.size);
+    for (const kv of x) {
+        bare.writeString(bc, kv[0]);
+        bare.writeString(bc, kv[1]);
+    }
+}
+export function readConn(bc) {
+    return {
+        id: bare.readString(bc),
+        parameters: readCbor(bc),
+        state: readCbor(bc),
+        subscriptions: read0(bc),
+        gatewayId: readGatewayId(bc),
+        requestId: readRequestId(bc),
+        serverMessageIndex: bare.readU16(bc),
+        clientMessageIndex: bare.readU16(bc),
+        requestPath: bare.readString(bc),
+        requestHeaders: read1(bc),
+    };
+}
+export function writeConn(bc, x) {
+    bare.writeString(bc, x.id);
+    writeCbor(bc, x.parameters);
+    writeCbor(bc, x.state);
+    write0(bc, x.subscriptions);
+    writeGatewayId(bc, x.gatewayId);
+    writeRequestId(bc, x.requestId);
+    bare.writeU16(bc, x.serverMessageIndex);
+    bare.writeU16(bc, x.clientMessageIndex);
+    bare.writeString(bc, x.requestPath);
+    write1(bc, x.requestHeaders);
+}
+export function encodeConn(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeConn(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeConn(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readConn(bc);
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes");
+    }
+    return result;
+}
+function read2(bc) {
+    return bare.readBool(bc)
+        ? readCbor(bc)
+        : null;
+}
+function write2(bc, x) {
+    bare.writeBool(bc, x !== null);
+    if (x !== null) {
+        writeCbor(bc, x);
+    }
+}
+export function readScheduleEvent(bc) {
+    return {
+        eventId: bare.readString(bc),
+        timestamp: bare.readI64(bc),
+        action: bare.readString(bc),
+        args: read2(bc),
+    };
+}
+export function writeScheduleEvent(bc, x) {
+    bare.writeString(bc, x.eventId);
+    bare.writeI64(bc, x.timestamp);
+    bare.writeString(bc, x.action);
+    write2(bc, x.args);
+}
+function read3(bc) {
+    const len = bare.readUintSafe(bc);
+    if (len === 0) {
+        return [];
+    }
+    const result = [readScheduleEvent(bc)];
+    for (let i = 1; i < len; i++) {
+        result[i] = readScheduleEvent(bc);
+    }
+    return result;
+}
+function write3(bc, x) {
+    bare.writeUintSafe(bc, x.length);
+    for (let i = 0; i < x.length; i++) {
+        writeScheduleEvent(bc, x[i]);
+    }
+}
+export function readActor(bc) {
+    return {
+        input: read2(bc),
+        hasInitialized: bare.readBool(bc),
+        state: readCbor(bc),
+        scheduledEvents: read3(bc),
+    };
+}
+export function writeActor(bc, x) {
+    write2(bc, x.input);
+    bare.writeBool(bc, x.hasInitialized);
+    writeCbor(bc, x.state);
+    write3(bc, x.scheduledEvents);
+}
+export function encodeActor(x) {
+    const bc = new bare.ByteCursor(new Uint8Array(config.initialBufferLength), config);
+    writeActor(bc, x);
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+export function decodeActor(bytes) {
+    const bc = new bare.ByteCursor(bytes, config);
+    const result = readActor(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");
+}