@rivetkit/workflow-engine 2.1.0-rc.1

package/dist/schemas/v1.ts

@@ -0,0 +1,781 @@
+// @generated - post-processed by compile-bare.ts
+import * as bare from "@rivetkit/bare-ts"
+
+const config = /* @__PURE__ */ bare.Config({})
+
+export type u32 = number
+export type u64 = bigint
+
+export type Cbor = ArrayBuffer
+
+export function readCbor(bc: bare.ByteCursor): Cbor {
+    return bare.readData(bc)
+}
+
+export function writeCbor(bc: bare.ByteCursor, x: Cbor): void {
+    bare.writeData(bc, x)
+}
+
+export type NameIndex = u32
+
+export function readNameIndex(bc: bare.ByteCursor): NameIndex {
+    return bare.readU32(bc)
+}
+
+export function writeNameIndex(bc: bare.ByteCursor, x: NameIndex): void {
+    bare.writeU32(bc, x)
+}
+
+export type LoopIterationMarker = {
+    readonly loop: NameIndex,
+    readonly iteration: u32,
+}
+
+export function readLoopIterationMarker(bc: bare.ByteCursor): LoopIterationMarker {
+    return {
+        loop: readNameIndex(bc),
+        iteration: bare.readU32(bc),
+    }
+}
+
+export function writeLoopIterationMarker(bc: bare.ByteCursor, x: LoopIterationMarker): void {
+    writeNameIndex(bc, x.loop)
+    bare.writeU32(bc, x.iteration)
+}
+
+export type PathSegment =
+    | { readonly tag: "NameIndex", readonly val: NameIndex }
+    | { readonly tag: "LoopIterationMarker", readonly val: LoopIterationMarker }
+
+export function readPathSegment(bc: bare.ByteCursor): PathSegment {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "NameIndex", val: readNameIndex(bc) }
+        case 1:
+            return { tag: "LoopIterationMarker", val: readLoopIterationMarker(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writePathSegment(bc: bare.ByteCursor, x: PathSegment): void {
+    switch (x.tag) {
+        case "NameIndex": {
+            bare.writeU8(bc, 0)
+            writeNameIndex(bc, x.val)
+            break
+        }
+        case "LoopIterationMarker": {
+            bare.writeU8(bc, 1)
+            writeLoopIterationMarker(bc, x.val)
+            break
+        }
+    }
+}
+
+export type Location = readonly PathSegment[]
+
+export function readLocation(bc: bare.ByteCursor): Location {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) { return [] }
+    const result = [readPathSegment(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readPathSegment(bc)
+    }
+    return result
+}
+
+export function writeLocation(bc: bare.ByteCursor, x: Location): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writePathSegment(bc, x[i])
+    }
+}
+
+export enum EntryStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    EXHAUSTED = "EXHAUSTED",
+}
+
+export function readEntryStatus(bc: bare.ByteCursor): EntryStatus {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return EntryStatus.PENDING
+        case 1:
+            return EntryStatus.RUNNING
+        case 2:
+            return EntryStatus.COMPLETED
+        case 3:
+            return EntryStatus.FAILED
+        case 4:
+            return EntryStatus.EXHAUSTED
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeEntryStatus(bc: bare.ByteCursor, x: EntryStatus): void {
+    switch (x) {
+        case EntryStatus.PENDING: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case EntryStatus.RUNNING: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case EntryStatus.COMPLETED: {
+            bare.writeU8(bc, 2)
+            break
+        }
+        case EntryStatus.FAILED: {
+            bare.writeU8(bc, 3)
+            break
+        }
+        case EntryStatus.EXHAUSTED: {
+            bare.writeU8(bc, 4)
+            break
+        }
+    }
+}
+
+export enum SleepState {
+    PENDING = "PENDING",
+    COMPLETED = "COMPLETED",
+    INTERRUPTED = "INTERRUPTED",
+}
+
+export function readSleepState(bc: bare.ByteCursor): SleepState {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return SleepState.PENDING
+        case 1:
+            return SleepState.COMPLETED
+        case 2:
+            return SleepState.INTERRUPTED
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSleepState(bc: bare.ByteCursor, x: SleepState): void {
+    switch (x) {
+        case SleepState.PENDING: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case SleepState.COMPLETED: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case SleepState.INTERRUPTED: {
+            bare.writeU8(bc, 2)
+            break
+        }
+    }
+}
+
+export enum BranchStatusType {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+}
+
+export function readBranchStatusType(bc: bare.ByteCursor): BranchStatusType {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return BranchStatusType.PENDING
+        case 1:
+            return BranchStatusType.RUNNING
+        case 2:
+            return BranchStatusType.COMPLETED
+        case 3:
+            return BranchStatusType.FAILED
+        case 4:
+            return BranchStatusType.CANCELLED
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeBranchStatusType(bc: bare.ByteCursor, x: BranchStatusType): void {
+    switch (x) {
+        case BranchStatusType.PENDING: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case BranchStatusType.RUNNING: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case BranchStatusType.COMPLETED: {
+            bare.writeU8(bc, 2)
+            break
+        }
+        case BranchStatusType.FAILED: {
+            bare.writeU8(bc, 3)
+            break
+        }
+        case BranchStatusType.CANCELLED: {
+            bare.writeU8(bc, 4)
+            break
+        }
+    }
+}
+
+function read0(bc: bare.ByteCursor): Cbor | null {
+    return bare.readBool(bc)
+        ? readCbor(bc)
+        : null
+}
+
+function write0(bc: bare.ByteCursor, x: Cbor | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        writeCbor(bc, x)
+    }
+}
+
+function read1(bc: bare.ByteCursor): string | null {
+    return bare.readBool(bc)
+        ? bare.readString(bc)
+        : null
+}
+
+function write1(bc: bare.ByteCursor, x: string | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        bare.writeString(bc, x)
+    }
+}
+
+export type StepEntry = {
+    readonly output: Cbor | null,
+    readonly error: string | null,
+}
+
+export function readStepEntry(bc: bare.ByteCursor): StepEntry {
+    return {
+        output: read0(bc),
+        error: read1(bc),
+    }
+}
+
+export function writeStepEntry(bc: bare.ByteCursor, x: StepEntry): void {
+    write0(bc, x.output)
+    write1(bc, x.error)
+}
+
+export type LoopEntry = {
+    readonly state: Cbor,
+    readonly iteration: u32,
+    readonly output: Cbor | null,
+}
+
+export function readLoopEntry(bc: bare.ByteCursor): LoopEntry {
+    return {
+        state: readCbor(bc),
+        iteration: bare.readU32(bc),
+        output: read0(bc),
+    }
+}
+
+export function writeLoopEntry(bc: bare.ByteCursor, x: LoopEntry): void {
+    writeCbor(bc, x.state)
+    bare.writeU32(bc, x.iteration)
+    write0(bc, x.output)
+}
+
+export type SleepEntry = {
+    readonly deadline: u64,
+    readonly state: SleepState,
+}
+
+export function readSleepEntry(bc: bare.ByteCursor): SleepEntry {
+    return {
+        deadline: bare.readU64(bc),
+        state: readSleepState(bc),
+    }
+}
+
+export function writeSleepEntry(bc: bare.ByteCursor, x: SleepEntry): void {
+    bare.writeU64(bc, x.deadline)
+    writeSleepState(bc, x.state)
+}
+
+export type MessageEntry = {
+    readonly name: string,
+    readonly messageData: Cbor,
+}
+
+export function readMessageEntry(bc: bare.ByteCursor): MessageEntry {
+    return {
+        name: bare.readString(bc),
+        messageData: readCbor(bc),
+    }
+}
+
+export function writeMessageEntry(bc: bare.ByteCursor, x: MessageEntry): void {
+    bare.writeString(bc, x.name)
+    writeCbor(bc, x.messageData)
+}
+
+export type RollbackCheckpointEntry = {
+    readonly name: string,
+}
+
+export function readRollbackCheckpointEntry(bc: bare.ByteCursor): RollbackCheckpointEntry {
+    return {
+        name: bare.readString(bc),
+    }
+}
+
+export function writeRollbackCheckpointEntry(bc: bare.ByteCursor, x: RollbackCheckpointEntry): void {
+    bare.writeString(bc, x.name)
+}
+
+export type BranchStatus = {
+    readonly status: BranchStatusType,
+    readonly output: Cbor | null,
+    readonly error: string | null,
+}
+
+export function readBranchStatus(bc: bare.ByteCursor): BranchStatus {
+    return {
+        status: readBranchStatusType(bc),
+        output: read0(bc),
+        error: read1(bc),
+    }
+}
+
+export function writeBranchStatus(bc: bare.ByteCursor, x: BranchStatus): void {
+    writeBranchStatusType(bc, x.status)
+    write0(bc, x.output)
+    write1(bc, x.error)
+}
+
+function read2(bc: bare.ByteCursor): ReadonlyMap<string, BranchStatus> {
+    const len = bare.readUintSafe(bc)
+    const result = new Map<string, BranchStatus>()
+    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, readBranchStatus(bc))
+    }
+    return result
+}
+
+function write2(bc: bare.ByteCursor, x: ReadonlyMap<string, BranchStatus>): void {
+    bare.writeUintSafe(bc, x.size)
+    for(const kv of x) {
+        bare.writeString(bc, kv[0])
+        writeBranchStatus(bc, kv[1])
+    }
+}
+
+export type JoinEntry = {
+    readonly branches: ReadonlyMap<string, BranchStatus>,
+}
+
+export function readJoinEntry(bc: bare.ByteCursor): JoinEntry {
+    return {
+        branches: read2(bc),
+    }
+}
+
+export function writeJoinEntry(bc: bare.ByteCursor, x: JoinEntry): void {
+    write2(bc, x.branches)
+}
+
+export type RaceEntry = {
+    readonly winner: string | null,
+    readonly branches: ReadonlyMap<string, BranchStatus>,
+}
+
+export function readRaceEntry(bc: bare.ByteCursor): RaceEntry {
+    return {
+        winner: read1(bc),
+        branches: read2(bc),
+    }
+}
+
+export function writeRaceEntry(bc: bare.ByteCursor, x: RaceEntry): void {
+    write1(bc, x.winner)
+    write2(bc, x.branches)
+}
+
+export type RemovedEntry = {
+    readonly originalType: string,
+    readonly originalName: string | null,
+}
+
+export function readRemovedEntry(bc: bare.ByteCursor): RemovedEntry {
+    return {
+        originalType: bare.readString(bc),
+        originalName: read1(bc),
+    }
+}
+
+export function writeRemovedEntry(bc: bare.ByteCursor, x: RemovedEntry): void {
+    bare.writeString(bc, x.originalType)
+    write1(bc, x.originalName)
+}
+
+export type EntryKind =
+    | { readonly tag: "StepEntry", readonly val: StepEntry }
+    | { readonly tag: "LoopEntry", readonly val: LoopEntry }
+    | { readonly tag: "SleepEntry", readonly val: SleepEntry }
+    | { readonly tag: "MessageEntry", readonly val: MessageEntry }
+    | { readonly tag: "RollbackCheckpointEntry", readonly val: RollbackCheckpointEntry }
+    | { readonly tag: "JoinEntry", readonly val: JoinEntry }
+    | { readonly tag: "RaceEntry", readonly val: RaceEntry }
+    | { readonly tag: "RemovedEntry", readonly val: RemovedEntry }
+
+export function readEntryKind(bc: bare.ByteCursor): EntryKind {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "StepEntry", val: readStepEntry(bc) }
+        case 1:
+            return { tag: "LoopEntry", val: readLoopEntry(bc) }
+        case 2:
+            return { tag: "SleepEntry", val: readSleepEntry(bc) }
+        case 3:
+            return { tag: "MessageEntry", val: readMessageEntry(bc) }
+        case 4:
+            return { tag: "RollbackCheckpointEntry", val: readRollbackCheckpointEntry(bc) }
+        case 5:
+            return { tag: "JoinEntry", val: readJoinEntry(bc) }
+        case 6:
+            return { tag: "RaceEntry", val: readRaceEntry(bc) }
+        case 7:
+            return { tag: "RemovedEntry", val: readRemovedEntry(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeEntryKind(bc: bare.ByteCursor, x: EntryKind): void {
+    switch (x.tag) {
+        case "StepEntry": {
+            bare.writeU8(bc, 0)
+            writeStepEntry(bc, x.val)
+            break
+        }
+        case "LoopEntry": {
+            bare.writeU8(bc, 1)
+            writeLoopEntry(bc, x.val)
+            break
+        }
+        case "SleepEntry": {
+            bare.writeU8(bc, 2)
+            writeSleepEntry(bc, x.val)
+            break
+        }
+        case "MessageEntry": {
+            bare.writeU8(bc, 3)
+            writeMessageEntry(bc, x.val)
+            break
+        }
+        case "RollbackCheckpointEntry": {
+            bare.writeU8(bc, 4)
+            writeRollbackCheckpointEntry(bc, x.val)
+            break
+        }
+        case "JoinEntry": {
+            bare.writeU8(bc, 5)
+            writeJoinEntry(bc, x.val)
+            break
+        }
+        case "RaceEntry": {
+            bare.writeU8(bc, 6)
+            writeRaceEntry(bc, x.val)
+            break
+        }
+        case "RemovedEntry": {
+            bare.writeU8(bc, 7)
+            writeRemovedEntry(bc, x.val)
+            break
+        }
+    }
+}
+
+export type Entry = {
+    readonly id: string,
+    readonly location: Location,
+    readonly kind: EntryKind,
+}
+
+export function readEntry(bc: bare.ByteCursor): Entry {
+    return {
+        id: bare.readString(bc),
+        location: readLocation(bc),
+        kind: readEntryKind(bc),
+    }
+}
+
+export function writeEntry(bc: bare.ByteCursor, x: Entry): void {
+    bare.writeString(bc, x.id)
+    writeLocation(bc, x.location)
+    writeEntryKind(bc, x.kind)
+}
+
+export function encodeEntry(x: Entry): Uint8Array {
+    const bc = new bare.ByteCursor(
+        new Uint8Array(config.initialBufferLength),
+        config
+    )
+    writeEntry(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeEntry(bytes: Uint8Array): Entry {
+    const bc = new bare.ByteCursor(bytes, config)
+    const result = readEntry(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+function read3(bc: bare.ByteCursor): u64 | null {
+    return bare.readBool(bc)
+        ? bare.readU64(bc)
+        : null
+}
+
+function write3(bc: bare.ByteCursor, x: u64 | null): void {
+    bare.writeBool(bc, x !== null)
+    if (x !== null) {
+        bare.writeU64(bc, x)
+    }
+}
+
+export type EntryMetadata = {
+    readonly status: EntryStatus,
+    readonly error: string | null,
+    readonly attempts: u32,
+    readonly lastAttemptAt: u64,
+    readonly createdAt: u64,
+    readonly completedAt: u64 | null,
+    readonly rollbackCompletedAt: u64 | null,
+    readonly rollbackError: string | null,
+}
+
+export function readEntryMetadata(bc: bare.ByteCursor): EntryMetadata {
+    return {
+        status: readEntryStatus(bc),
+        error: read1(bc),
+        attempts: bare.readU32(bc),
+        lastAttemptAt: bare.readU64(bc),
+        createdAt: bare.readU64(bc),
+        completedAt: read3(bc),
+        rollbackCompletedAt: read3(bc),
+        rollbackError: read1(bc),
+    }
+}
+
+export function writeEntryMetadata(bc: bare.ByteCursor, x: EntryMetadata): void {
+    writeEntryStatus(bc, x.status)
+    write1(bc, x.error)
+    bare.writeU32(bc, x.attempts)
+    bare.writeU64(bc, x.lastAttemptAt)
+    bare.writeU64(bc, x.createdAt)
+    write3(bc, x.completedAt)
+    write3(bc, x.rollbackCompletedAt)
+    write1(bc, x.rollbackError)
+}
+
+export function encodeEntryMetadata(x: EntryMetadata): Uint8Array {
+    const bc = new bare.ByteCursor(
+        new Uint8Array(config.initialBufferLength),
+        config
+    )
+    writeEntryMetadata(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeEntryMetadata(bytes: Uint8Array): EntryMetadata {
+    const bc = new bare.ByteCursor(bytes, config)
+    const result = readEntryMetadata(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+export type Message = {
+    readonly id: string,
+    readonly name: string,
+    readonly messageData: Cbor,
+    readonly sentAt: u64,
+}
+
+export function readMessage(bc: bare.ByteCursor): Message {
+    return {
+        id: bare.readString(bc),
+        name: bare.readString(bc),
+        messageData: readCbor(bc),
+        sentAt: bare.readU64(bc),
+    }
+}
+
+export function writeMessage(bc: bare.ByteCursor, x: Message): void {
+    bare.writeString(bc, x.id)
+    bare.writeString(bc, x.name)
+    writeCbor(bc, x.messageData)
+    bare.writeU64(bc, x.sentAt)
+}
+
+export function encodeMessage(x: Message): Uint8Array {
+    const bc = new bare.ByteCursor(
+        new Uint8Array(config.initialBufferLength),
+        config
+    )
+    writeMessage(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeMessage(bytes: Uint8Array): Message {
+    const bc = new bare.ByteCursor(bytes, config)
+    const result = readMessage(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+export enum WorkflowState {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SLEEPING = "SLEEPING",
+    FAILED = "FAILED",
+    COMPLETED = "COMPLETED",
+    ROLLING_BACK = "ROLLING_BACK",
+}
+
+export function readWorkflowState(bc: bare.ByteCursor): WorkflowState {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return WorkflowState.PENDING
+        case 1:
+            return WorkflowState.RUNNING
+        case 2:
+            return WorkflowState.SLEEPING
+        case 3:
+            return WorkflowState.FAILED
+        case 4:
+            return WorkflowState.COMPLETED
+        case 5:
+            return WorkflowState.ROLLING_BACK
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeWorkflowState(bc: bare.ByteCursor, x: WorkflowState): void {
+    switch (x) {
+        case WorkflowState.PENDING: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case WorkflowState.RUNNING: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case WorkflowState.SLEEPING: {
+            bare.writeU8(bc, 2)
+            break
+        }
+        case WorkflowState.FAILED: {
+            bare.writeU8(bc, 3)
+            break
+        }
+        case WorkflowState.COMPLETED: {
+            bare.writeU8(bc, 4)
+            break
+        }
+        case WorkflowState.ROLLING_BACK: {
+            bare.writeU8(bc, 5)
+            break
+        }
+    }
+}
+
+export type WorkflowMetadata = {
+    readonly state: WorkflowState,
+    readonly output: Cbor | null,
+    readonly error: string | null,
+    readonly version: string | null,
+}
+
+export function readWorkflowMetadata(bc: bare.ByteCursor): WorkflowMetadata {
+    return {
+        state: readWorkflowState(bc),
+        output: read0(bc),
+        error: read1(bc),
+        version: read1(bc),
+    }
+}
+
+export function writeWorkflowMetadata(bc: bare.ByteCursor, x: WorkflowMetadata): void {
+    writeWorkflowState(bc, x.state)
+    write0(bc, x.output)
+    write1(bc, x.error)
+    write1(bc, x.version)
+}
+
+export function encodeWorkflowMetadata(x: WorkflowMetadata): Uint8Array {
+    const bc = new bare.ByteCursor(
+        new Uint8Array(config.initialBufferLength),
+        config
+    )
+    writeWorkflowMetadata(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeWorkflowMetadata(bytes: Uint8Array): WorkflowMetadata {
+    const bc = new bare.ByteCursor(bytes, config)
+    const result = readWorkflowMetadata(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+
+function assert(condition: boolean, message?: string): asserts condition {
+    if (!condition) throw new Error(message ?? "Assertion failed")
+}