@radishbot/sdk 0.3.1 → 0.4.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/connection.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SpacetimeDB connection wrapper for the Radish SDK.
+ * Uses the generated bindings + SpacetimeDB WebSocket client.
+ */
+import { DbConnection as StdbConnection } from './module_bindings';
+export declare class SdkConnection {
+    private _host;
+    private _dbName;
+    private _conn;
+    private _connectPromise;
+    private _timeoutInterval;
+    private _keyHash;
+    private _flowWaiters;
+    constructor(host: string, dbName: string);
+    setKeyHash(keyHash: string): void;
+    connect(): Promise<StdbConnection>;
+    get conn(): StdbConnection;
+    /**
+     * Call a reducer and wait for the flow to appear in the subscription.
+     * Returns the server-assigned flow ID.
+     */
+    createFlowAndResolveId(reducerCall: () => void, exportToken: string): Promise<bigint>;
+    disconnect(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export type LogLevel = "info" | "warn" | "error" | "debug";
+
+export declare class Flow {
+  log(message: string, data?: unknown, level?: LogLevel): this;
+  info(message: string, data?: unknown): this;
+  warn(message: string, data?: unknown): this;
+  error(message: string, data?: unknown): this;
+  debug(message: string, data?: unknown): this;
+  action(name: string, timeoutSeconds?: number): Flow;
+  flow(name: string, timeoutSeconds?: number): Flow;
+  a<T>(name: string, fn: (action: Flow) => T | Promise<T>, timeoutSeconds?: number): Promise<T>;
+  finish(): Promise<void>;
+  finishWithError(err?: Error | string): Promise<void>;
+  exportID(): Promise<string>;
+  getId(): Promise<bigint>;
+  disconnect(): void;
+  finishAndDisconnect(): Promise<void>;
+}
+
+export interface RLOptions {
+  host?: string;
+  dbName?: string;
+  label?: string;
+  defaultTimeout?: number;
+  release?: string;
+  retention?: string;
+}
+
+export declare function RL(secretKey: string, options?: RLOptions): Promise<Flow>;
+export declare function restoreFlow(secretKey: string, exportedId: string, options?: RLOptions): Promise<Flow>;
+export declare function generateKey(): string;

package/dist/index.js

@@ -0,0 +1,688 @@
+// src/module_bindings/index.ts
+import {
+  DbConnectionBuilder as __DbConnectionBuilder,
+  DbConnectionImpl as __DbConnectionImpl,
+  SubscriptionBuilderImpl as __SubscriptionBuilderImpl,
+  convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
+  procedures as __procedures,
+  reducerSchema as __reducerSchema,
+  reducers as __reducers,
+  schema as __schema,
+  table as __table
+} from "spacetimedb";
+
+// src/module_bindings/add_log_reducer.ts
+import {
+  t as __t
+} from "spacetimedb";
+var add_log_reducer_default = {
+  keyHash: __t.string(),
+  flowId: __t.u64(),
+  level: __t.string(),
+  message: __t.string(),
+  data: __t.string()
+};
+
+// src/module_bindings/add_logs_batch_reducer.ts
+import {
+  t as __t2
+} from "spacetimedb";
+var add_logs_batch_reducer_default = {
+  keyHash: __t2.string(),
+  flowId: __t2.u64(),
+  entries: __t2.string()
+};
+
+// src/module_bindings/check_timeouts_reducer.ts
+import {
+  t as __t3
+} from "spacetimedb";
+var check_timeouts_reducer_default = {
+  keyHash: __t3.string()
+};
+
+// src/module_bindings/create_root_flow_reducer.ts
+import {
+  t as __t4
+} from "spacetimedb";
+var create_root_flow_reducer_default = {
+  keyHash: __t4.string(),
+  timeoutSeconds: __t4.u64(),
+  exportToken: __t4.string(),
+  release: __t4.string()
+};
+
+// src/module_bindings/create_sub_flow_reducer.ts
+import {
+  t as __t5
+} from "spacetimedb";
+var create_sub_flow_reducer_default = {
+  keyHash: __t5.string(),
+  parentFlowId: __t5.u64(),
+  name: __t5.string(),
+  timeoutSeconds: __t5.u64(),
+  exportToken: __t5.string()
+};
+
+// src/module_bindings/finish_action_reducer.ts
+import {
+  t as __t6
+} from "spacetimedb";
+var finish_action_reducer_default = {
+  keyHash: __t6.string(),
+  actionId: __t6.u64(),
+  status: __t6.string()
+};
+
+// src/module_bindings/finish_flow_reducer.ts
+import {
+  t as __t7
+} from "spacetimedb";
+var finish_flow_reducer_default = {
+  keyHash: __t7.string(),
+  flowId: __t7.u64(),
+  status: __t7.string(),
+  errorMessage: __t7.string()
+};
+
+// src/module_bindings/register_key_reducer.ts
+import {
+  t as __t8
+} from "spacetimedb";
+var register_key_reducer_default = {
+  keyHash: __t8.string(),
+  label: __t8.string(),
+  retentionDays: __t8.u64()
+};
+
+// src/module_bindings/start_action_reducer.ts
+import {
+  t as __t9
+} from "spacetimedb";
+var start_action_reducer_default = {
+  keyHash: __t9.string(),
+  flowId: __t9.u64(),
+  name: __t9.string()
+};
+
+// src/module_bindings/update_error_group_status_reducer.ts
+import {
+  t as __t10
+} from "spacetimedb";
+var update_error_group_status_reducer_default = {
+  keyHash: __t10.string(),
+  errorGroupId: __t10.u64(),
+  status: __t10.string()
+};
+
+// src/module_bindings/action_table.ts
+import {
+  t as __t11
+} from "spacetimedb";
+var action_table_default = __t11.row({
+  id: __t11.u64().primaryKey(),
+  flowId: __t11.u64().name("flow_id"),
+  name: __t11.string(),
+  status: __t11.string(),
+  createdAt: __t11.timestamp().name("created_at"),
+  finishedAt: __t11.u64().name("finished_at")
+});
+
+// src/module_bindings/api_key_table.ts
+import {
+  t as __t12
+} from "spacetimedb";
+var api_key_table_default = __t12.row({
+  keyHash: __t12.string().primaryKey().name("key_hash"),
+  label: __t12.string(),
+  retentionDays: __t12.u64().name("retention_days"),
+  createdAt: __t12.timestamp().name("created_at")
+});
+
+// src/module_bindings/error_group_table.ts
+import {
+  t as __t13
+} from "spacetimedb";
+var error_group_table_default = __t13.row({
+  id: __t13.u64().primaryKey(),
+  keyHash: __t13.string().name("key_hash"),
+  fingerprint: __t13.string(),
+  message: __t13.string(),
+  path: __t13.string(),
+  release: __t13.string(),
+  count: __t13.u64(),
+  status: __t13.string(),
+  firstSeenAt: __t13.timestamp().name("first_seen_at"),
+  lastSeenAt: __t13.u64().name("last_seen_at"),
+  lastFlowId: __t13.u64().name("last_flow_id")
+});
+
+// src/module_bindings/flow_table.ts
+import {
+  t as __t14
+} from "spacetimedb";
+var flow_table_default = __t14.row({
+  id: __t14.u64().primaryKey(),
+  keyHash: __t14.string().name("key_hash"),
+  parentFlowId: __t14.u64().name("parent_flow_id"),
+  name: __t14.string(),
+  path: __t14.string(),
+  status: __t14.string(),
+  release: __t14.string(),
+  timeoutSeconds: __t14.u64().name("timeout_seconds"),
+  createdAt: __t14.timestamp().name("created_at"),
+  finishedAt: __t14.u64().name("finished_at"),
+  exportToken: __t14.string().name("export_token")
+});
+
+// src/module_bindings/log_entry_table.ts
+import {
+  t as __t15
+} from "spacetimedb";
+var log_entry_table_default = __t15.row({
+  id: __t15.u64().primaryKey(),
+  flowId: __t15.u64().name("flow_id"),
+  level: __t15.string(),
+  message: __t15.string(),
+  data: __t15.string(),
+  createdAt: __t15.timestamp().name("created_at")
+});
+
+// src/module_bindings/index.ts
+var tablesSchema = __schema({
+  action: __table({
+    name: "action",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "action_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, action_table_default),
+  apiKey: __table({
+    name: "api_key",
+    indexes: [
+      { name: "keyHash", algorithm: "btree", columns: [
+        "keyHash"
+      ] }
+    ],
+    constraints: [
+      { name: "api_key_key_hash_key", constraint: "unique", columns: ["keyHash"] }
+    ]
+  }, api_key_table_default),
+  errorGroup: __table({
+    name: "error_group",
+    indexes: [
+      { name: "fingerprint", algorithm: "btree", columns: [
+        "fingerprint"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "error_group_fingerprint_key", constraint: "unique", columns: ["fingerprint"] },
+      { name: "error_group_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, error_group_table_default),
+  flow: __table({
+    name: "flow",
+    indexes: [
+      { name: "exportToken", algorithm: "btree", columns: [
+        "exportToken"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "flow_export_token_key", constraint: "unique", columns: ["exportToken"] },
+      { name: "flow_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, flow_table_default),
+  logEntry: __table({
+    name: "log_entry",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "log_entry_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, log_entry_table_default)
+});
+var reducersSchema = __reducers(__reducerSchema("add_log", add_log_reducer_default), __reducerSchema("add_logs_batch", add_logs_batch_reducer_default), __reducerSchema("check_timeouts", check_timeouts_reducer_default), __reducerSchema("create_root_flow", create_root_flow_reducer_default), __reducerSchema("create_sub_flow", create_sub_flow_reducer_default), __reducerSchema("finish_action", finish_action_reducer_default), __reducerSchema("finish_flow", finish_flow_reducer_default), __reducerSchema("register_key", register_key_reducer_default), __reducerSchema("start_action", start_action_reducer_default), __reducerSchema("update_error_group_status", update_error_group_status_reducer_default));
+var proceduresSchema = __procedures();
+var REMOTE_MODULE = {
+  versionInfo: {
+    cliVersion: "2.0.3"
+  },
+  tables: tablesSchema.schemaType.tables,
+  reducers: reducersSchema.reducersType.reducers,
+  ...proceduresSchema
+};
+var tables = __makeQueryBuilder(tablesSchema.schemaType);
+var reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);
+
+class SubscriptionBuilder extends __SubscriptionBuilderImpl {
+}
+
+class DbConnectionBuilder extends __DbConnectionBuilder {
+}
+
+class DbConnection extends __DbConnectionImpl {
+  static builder = () => {
+    return new DbConnectionBuilder(REMOTE_MODULE, (config) => new DbConnection(config));
+  };
+  subscriptionBuilder = () => {
+    return new SubscriptionBuilder(this);
+  };
+}
+
+// src/connection.ts
+class SdkConnection {
+  _host;
+  _dbName;
+  _conn = null;
+  _connectPromise = null;
+  _timeoutInterval = null;
+  _keyHash = null;
+  _flowWaiters = new Map;
+  constructor(host, dbName) {
+    this._host = host;
+    this._dbName = dbName;
+  }
+  setKeyHash(keyHash) {
+    this._keyHash = keyHash;
+  }
+  async connect() {
+    if (this._conn)
+      return this._conn;
+    if (this._connectPromise)
+      return this._connectPromise;
+    this._connectPromise = new Promise((resolve, reject) => {
+      const conn = DbConnection.builder().withUri(this._host).withDatabaseName(this._dbName).onConnect((c, _identity, _token) => {
+        this._conn = c;
+        c.subscriptionBuilder().onApplied(() => {
+          resolve(c);
+        }).subscribeToAllTables();
+        this._timeoutInterval = setInterval(() => {
+          if (this._keyHash) {
+            c.reducers.checkTimeouts({ keyHash: this._keyHash });
+          }
+        }, 30000);
+      }).onConnectError((_ctx, err) => {
+        reject(new Error(`SpacetimeDB connection failed: ${err}`));
+      }).build();
+    });
+    return this._connectPromise;
+  }
+  get conn() {
+    if (!this._conn)
+      throw new Error("Not connected");
+    return this._conn;
+  }
+  async createFlowAndResolveId(reducerCall, exportToken) {
+    const conn = this.conn;
+    for (const f of conn.db.flow.iter()) {
+      if (f.exportToken === exportToken)
+        return f.id;
+    }
+    return new Promise((resolve) => {
+      this._flowWaiters.set(exportToken, resolve);
+      reducerCall();
+      const check = () => {
+        for (const f of conn.db.flow.iter()) {
+          if (f.exportToken === exportToken) {
+            this._flowWaiters.delete(exportToken);
+            resolve(f.id);
+            return true;
+          }
+        }
+        return false;
+      };
+      let attempts = 0;
+      const interval = setInterval(() => {
+        if (check() || attempts++ > 100) {
+          clearInterval(interval);
+          if (attempts > 100) {
+            this._flowWaiters.delete(exportToken);
+            throw new Error(`Flow creation timed out for token ${exportToken}`);
+          }
+        }
+      }, 100);
+    });
+  }
+  disconnect() {
+    if (this._timeoutInterval) {
+      clearInterval(this._timeoutInterval);
+      this._timeoutInterval = null;
+    }
+    if (this._conn) {
+      this._conn.disconnect();
+      this._conn = null;
+    }
+  }
+}
+
+// src/index.ts
+var _origConsole = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+var _flowStack = [];
+function _patchConsole() {
+  const capture = (level) => (...args) => {
+    const flow = _flowStack[_flowStack.length - 1];
+    if (flow) {
+      const msg = args.map((a) => {
+        if (typeof a === "string")
+          return a;
+        if (a instanceof Error)
+          return a.message;
+        try {
+          return JSON.stringify(a);
+        } catch {
+          return String(a);
+        }
+      }).join(" ");
+      const data = args.length <= 1 ? undefined : args.length === 2 ? args[1] : args.slice(1);
+      flow.log(msg, data, level);
+    }
+    _origConsole[level === "info" ? "log" : level](...args);
+  };
+  console.log = capture("info");
+  console.info = capture("info");
+  console.warn = capture("warn");
+  console.error = capture("error");
+  console.debug = capture("debug");
+}
+function _restoreConsole() {
+  console.log = _origConsole.log;
+  console.info = _origConsole.info;
+  console.warn = _origConsole.warn;
+  console.error = _origConsole.error;
+  console.debug = _origConsole.debug;
+}
+function serialize(value) {
+  if (value === undefined || value === null)
+    return "{}";
+  if (value instanceof Error)
+    return JSON.stringify({
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    });
+  try {
+    return JSON.stringify(value, (_key, v) => typeof v === "bigint" ? v.toString() : v);
+  } catch {
+    return JSON.stringify({ value: String(value) });
+  }
+}
+async function hashKey(secretKey) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(secretKey);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateToken() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+class Flow {
+  _sdk;
+  _keyHash;
+  _id = null;
+  _exportToken;
+  _ready;
+  _resolveReady;
+  _pendingLogs = [];
+  _flushScheduled = false;
+  _isReady = false;
+  _finished = false;
+  _parentId;
+  _name;
+  _timeoutSeconds;
+  _release;
+  constructor(sdk, keyHash, parentId, name, timeoutSeconds, release = "") {
+    this._sdk = sdk;
+    this._keyHash = keyHash;
+    this._parentId = parentId;
+    this._name = name;
+    this._timeoutSeconds = !timeoutSeconds || timeoutSeconds === Infinity ? 0n : BigInt(timeoutSeconds);
+    this._release = release;
+    this._exportToken = generateToken();
+    this._ready = new Promise((resolve) => {
+      this._resolveReady = resolve;
+    });
+  }
+  async _create() {
+    const conn = this._sdk.conn;
+    const exportToken = this._exportToken;
+    const keyHash = this._keyHash;
+    const timeoutSeconds = this._timeoutSeconds;
+    if (this._parentId === 0n) {
+      const id = await this._sdk.createFlowAndResolveId(() => conn.reducers.createRootFlow({ keyHash, timeoutSeconds, exportToken, release: this._release }), exportToken);
+      this._id = id;
+    } else {
+      const parentFlowId = this._parentId;
+      const name = this._name;
+      const id = await this._sdk.createFlowAndResolveId(() => conn.reducers.createSubFlow({
+        keyHash,
+        parentFlowId,
+        name,
+        timeoutSeconds,
+        exportToken
+      }), exportToken);
+      this._id = id;
+    }
+    this._isReady = true;
+    this._resolveReady();
+    this._drain();
+  }
+  static MAX_PENDING = 1e4;
+  log(message, data, level = "info") {
+    if (this._finished) {
+      console.warn(`[radish] Cannot log to finished flow`);
+      return this;
+    }
+    if (this._pendingLogs.length >= Flow.MAX_PENDING) {
+      const dropped = this._pendingLogs.length - Flow.MAX_PENDING + 1;
+      this._pendingLogs.splice(0, dropped);
+    }
+    this._pendingLogs.push({
+      level,
+      message,
+      data: data !== undefined ? serialize(data) : "{}"
+    });
+    this._scheduleFlush();
+    return this;
+  }
+  info(message, data) {
+    return this.log(message, data, "info");
+  }
+  warn(message, data) {
+    return this.log(message, data, "warn");
+  }
+  error(message, data) {
+    return this.log(message, data, "error");
+  }
+  debug(message, data) {
+    return this.log(message, data, "debug");
+  }
+  action(name, timeoutSeconds = 100) {
+    const child = new Flow(this._sdk, this._keyHash, 0n, name, timeoutSeconds, this._release);
+    this._ready.then(() => {
+      child._parentId = this._id;
+      child._create();
+    });
+    return child;
+  }
+  flow(name, timeoutSeconds = 100) {
+    return this.action(name, timeoutSeconds);
+  }
+  async a(name, fn, timeoutSeconds = 100) {
+    const child = this.action(name, timeoutSeconds);
+    _flowStack.push(child);
+    _patchConsole();
+    try {
+      const result = await fn(child);
+      await child.finish();
+      return result;
+    } catch (e) {
+      await child.finishWithError(e instanceof Error ? e : String(e));
+      throw e;
+    } finally {
+      _flowStack.pop();
+      if (_flowStack.length === 0)
+        _restoreConsole();
+    }
+  }
+  async finish() {
+    await this._ready;
+    this._drain();
+    this._finished = true;
+    this._sdk.conn.reducers.finishFlow({
+      keyHash: this._keyHash,
+      flowId: this._id,
+      status: "finished",
+      errorMessage: ""
+    });
+  }
+  async finishWithError(err) {
+    const errorMessage = err ? typeof err === "string" ? err : err.message : "";
+    if (err) {
+      this.error(errorMessage, err);
+    }
+    await this._ready;
+    this._drain();
+    this._finished = true;
+    this._sdk.conn.reducers.finishFlow({
+      keyHash: this._keyHash,
+      flowId: this._id,
+      status: "error",
+      errorMessage
+    });
+  }
+  async exportID() {
+    await this._ready;
+    return JSON.stringify({
+      flowId: this._id.toString(),
+      exportToken: this._exportToken,
+      keyHash: this._keyHash
+    });
+  }
+  async getId() {
+    await this._ready;
+    return this._id;
+  }
+  disconnect() {
+    this._sdk.disconnect();
+  }
+  async finishAndDisconnect() {
+    await this.finish();
+    await new Promise((r) => setTimeout(r, 100));
+    this.disconnect();
+  }
+  _scheduleFlush() {
+    if (this._flushScheduled)
+      return;
+    this._flushScheduled = true;
+    queueMicrotask(() => {
+      this._flushScheduled = false;
+      this._drain();
+    });
+  }
+  _drain() {
+    if (!this._isReady || this._pendingLogs.length === 0)
+      return;
+    const batch = this._pendingLogs.splice(0);
+    const conn = this._sdk.conn;
+    if (batch.length === 1) {
+      const e = batch[0];
+      conn.reducers.addLog({
+        keyHash: this._keyHash,
+        flowId: this._id,
+        level: e.level,
+        message: e.message,
+        data: e.data
+      });
+    } else {
+      conn.reducers.addLogsBatch({
+        keyHash: this._keyHash,
+        flowId: this._id,
+        entries: JSON.stringify(batch)
+      });
+    }
+  }
+}
+function parseRetention(retention) {
+  const match = retention.match(/^(\d+)d$/);
+  if (!match)
+    throw new Error('Invalid retention format. Use e.g. "30d"');
+  return parseInt(match[1], 10);
+}
+async function RL(secretKey, options = {}) {
+  const {
+    host = "wss://maincloud.spacetimedb.com",
+    dbName = "radish-log",
+    label = "",
+    defaultTimeout = 100,
+    release = "",
+    retention = "30d"
+  } = options;
+  const retentionDays = parseRetention(retention);
+  const keyHash = await hashKey(secretKey);
+  const sdk = new SdkConnection(host, dbName);
+  sdk.setKeyHash(keyHash);
+  try {
+    await sdk.connect();
+  } catch (e) {
+    throw new Error(`Failed to connect to Radish (${host}/${dbName}): ${e instanceof Error ? e.message : e}`);
+  }
+  try {
+    sdk.conn.reducers.registerKey({ keyHash, label, retentionDays: BigInt(retentionDays) });
+  } catch {}
+  try {
+    sdk.conn.reducers.checkTimeouts({ keyHash });
+  } catch {}
+  const root = new Flow(sdk, keyHash, 0n, "/", 0, release);
+  root._create();
+  return root;
+}
+async function restoreFlow(secretKey, exportedId, options = {}) {
+  const { host = "wss://maincloud.spacetimedb.com", dbName = "radish-log" } = options;
+  const parsed = JSON.parse(exportedId);
+  const keyHash = await hashKey(secretKey);
+  if (keyHash !== parsed.keyHash) {
+    throw new Error("Secret key does not match the flow owner");
+  }
+  const sdk = new SdkConnection(host, dbName);
+  await sdk.connect();
+  const flow = new Flow(sdk, keyHash, 0n, "restored", 100);
+  flow._id = BigInt(parsed.flowId);
+  flow._exportToken = parsed.exportToken;
+  flow._resolveReady();
+  return flow;
+}
+function generateKey() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return "rl_" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export {
+  restoreFlow,
+  generateKey,
+  RL,
+  Flow
+};

package/dist/module_bindings/action_table.d.ts

@@ -0,0 +1,17 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    flowId: import("spacetimedb").U64ColumnBuilder<{
+        name: "flow_id";
+    }>;
+    name: import("spacetimedb").StringBuilder;
+    status: import("spacetimedb").StringBuilder;
+    createdAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "created_at";
+    }>;
+    finishedAt: import("spacetimedb").U64ColumnBuilder<{
+        name: "finished_at";
+    }>;
+}>;
+export default _default;

package/dist/module_bindings/add_log_reducer.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    flowId: import("spacetimedb").U64Builder;
+    level: import("spacetimedb").StringBuilder;
+    message: import("spacetimedb").StringBuilder;
+    data: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/add_logs_batch_reducer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    flowId: import("spacetimedb").U64Builder;
+    entries: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/api_key_table.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    keyHash: import("spacetimedb").StringColumnBuilder<{
+        isPrimaryKey: true;
+        name: "key_hash";
+    }>;
+    label: import("spacetimedb").StringBuilder;
+    retentionDays: import("spacetimedb").U64ColumnBuilder<{
+        name: "retention_days";
+    }>;
+    createdAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "created_at";
+    }>;
+}>;
+export default _default;

package/dist/module_bindings/check_timeouts_reducer.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/create_root_flow_reducer.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    timeoutSeconds: import("spacetimedb").U64Builder;
+    exportToken: import("spacetimedb").StringBuilder;
+    release: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/create_sub_flow_reducer.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    parentFlowId: import("spacetimedb").U64Builder;
+    name: import("spacetimedb").StringBuilder;
+    timeoutSeconds: import("spacetimedb").U64Builder;
+    exportToken: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/error_group_table.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    keyHash: import("spacetimedb").StringColumnBuilder<{
+        name: "key_hash";
+    }>;
+    fingerprint: import("spacetimedb").StringBuilder;
+    message: import("spacetimedb").StringBuilder;
+    path: import("spacetimedb").StringBuilder;
+    release: import("spacetimedb").StringBuilder;
+    count: import("spacetimedb").U64Builder;
+    status: import("spacetimedb").StringBuilder;
+    firstSeenAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "first_seen_at";
+    }>;
+    lastSeenAt: import("spacetimedb").U64ColumnBuilder<{
+        name: "last_seen_at";
+    }>;
+    lastFlowId: import("spacetimedb").U64ColumnBuilder<{
+        name: "last_flow_id";
+    }>;
+}>;
+export default _default;

package/dist/module_bindings/finish_action_reducer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    actionId: import("spacetimedb").U64Builder;
+    status: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/finish_flow_reducer.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    flowId: import("spacetimedb").U64Builder;
+    status: import("spacetimedb").StringBuilder;
+    errorMessage: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/flow_table.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    keyHash: import("spacetimedb").StringColumnBuilder<{
+        name: "key_hash";
+    }>;
+    parentFlowId: import("spacetimedb").U64ColumnBuilder<{
+        name: "parent_flow_id";
+    }>;
+    name: import("spacetimedb").StringBuilder;
+    path: import("spacetimedb").StringBuilder;
+    status: import("spacetimedb").StringBuilder;
+    release: import("spacetimedb").StringBuilder;
+    timeoutSeconds: import("spacetimedb").U64ColumnBuilder<{
+        name: "timeout_seconds";
+    }>;
+    createdAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "created_at";
+    }>;
+    finishedAt: import("spacetimedb").U64ColumnBuilder<{
+        name: "finished_at";
+    }>;
+    exportToken: import("spacetimedb").StringColumnBuilder<{
+        name: "export_token";
+    }>;
+}>;
+export default _default;

package/dist/module_bindings/log_entry_table.d.ts

@@ -0,0 +1,15 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    flowId: import("spacetimedb").U64ColumnBuilder<{
+        name: "flow_id";
+    }>;
+    level: import("spacetimedb").StringBuilder;
+    message: import("spacetimedb").StringBuilder;
+    data: import("spacetimedb").StringBuilder;
+    createdAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "created_at";
+    }>;
+}>;
+export default _default;

package/dist/module_bindings/register_key_reducer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    label: import("spacetimedb").StringBuilder;
+    retentionDays: import("spacetimedb").U64Builder;
+};
+export default _default;

package/dist/module_bindings/start_action_reducer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    flowId: import("spacetimedb").U64Builder;
+    name: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/dist/module_bindings/types/procedures.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/module_bindings/types/reducers.d.ts

@@ -0,0 +1,21 @@
+import { type Infer as __Infer } from "spacetimedb";
+import AddLogReducer from "../add_log_reducer";
+import AddLogsBatchReducer from "../add_logs_batch_reducer";
+import CheckTimeoutsReducer from "../check_timeouts_reducer";
+import CreateRootFlowReducer from "../create_root_flow_reducer";
+import CreateSubFlowReducer from "../create_sub_flow_reducer";
+import FinishActionReducer from "../finish_action_reducer";
+import FinishFlowReducer from "../finish_flow_reducer";
+import RegisterKeyReducer from "../register_key_reducer";
+import StartActionReducer from "../start_action_reducer";
+import UpdateErrorGroupStatusReducer from "../update_error_group_status_reducer";
+export type AddLogParams = __Infer<typeof AddLogReducer>;
+export type AddLogsBatchParams = __Infer<typeof AddLogsBatchReducer>;
+export type CheckTimeoutsParams = __Infer<typeof CheckTimeoutsReducer>;
+export type CreateRootFlowParams = __Infer<typeof CreateRootFlowReducer>;
+export type CreateSubFlowParams = __Infer<typeof CreateSubFlowReducer>;
+export type FinishActionParams = __Infer<typeof FinishActionReducer>;
+export type FinishFlowParams = __Infer<typeof FinishFlowReducer>;
+export type RegisterKeyParams = __Infer<typeof RegisterKeyReducer>;
+export type StartActionParams = __Infer<typeof StartActionReducer>;
+export type UpdateErrorGroupStatusParams = __Infer<typeof UpdateErrorGroupStatusReducer>;

package/dist/module_bindings/types.d.ts

@@ -0,0 +1,59 @@
+import { type Infer as __Infer } from "spacetimedb";
+export declare const Action: import("spacetimedb").ProductBuilder<{
+    id: import("spacetimedb").U64Builder;
+    flowId: import("spacetimedb").U64Builder;
+    name: import("spacetimedb").StringBuilder;
+    status: import("spacetimedb").StringBuilder;
+    createdAt: import("spacetimedb").TimestampBuilder;
+    finishedAt: import("spacetimedb").U64Builder;
+}>;
+export type Action = __Infer<typeof Action>;
+export declare const ApiKey: import("spacetimedb").ProductBuilder<{
+    keyHash: import("spacetimedb").StringBuilder;
+    label: import("spacetimedb").StringBuilder;
+    retentionDays: import("spacetimedb").U64Builder;
+    createdAt: import("spacetimedb").TimestampBuilder;
+}>;
+export type ApiKey = __Infer<typeof ApiKey>;
+export declare const ErrorGroup: import("spacetimedb").ProductBuilder<{
+    id: import("spacetimedb").U64Builder;
+    keyHash: import("spacetimedb").StringBuilder;
+    fingerprint: import("spacetimedb").StringBuilder;
+    message: import("spacetimedb").StringBuilder;
+    path: import("spacetimedb").StringBuilder;
+    release: import("spacetimedb").StringBuilder;
+    count: import("spacetimedb").U64Builder;
+    status: import("spacetimedb").StringBuilder;
+    firstSeenAt: import("spacetimedb").TimestampBuilder;
+    lastSeenAt: import("spacetimedb").U64Builder;
+    lastFlowId: import("spacetimedb").U64Builder;
+}>;
+export type ErrorGroup = __Infer<typeof ErrorGroup>;
+export declare const Flow: import("spacetimedb").ProductBuilder<{
+    id: import("spacetimedb").U64Builder;
+    keyHash: import("spacetimedb").StringBuilder;
+    parentFlowId: import("spacetimedb").U64Builder;
+    name: import("spacetimedb").StringBuilder;
+    path: import("spacetimedb").StringBuilder;
+    status: import("spacetimedb").StringBuilder;
+    release: import("spacetimedb").StringBuilder;
+    timeoutSeconds: import("spacetimedb").U64Builder;
+    createdAt: import("spacetimedb").TimestampBuilder;
+    finishedAt: import("spacetimedb").U64Builder;
+    exportToken: import("spacetimedb").StringBuilder;
+}>;
+export type Flow = __Infer<typeof Flow>;
+export declare const GcJob: import("spacetimedb").ProductBuilder<{
+    scheduledId: import("spacetimedb").U64Builder;
+    scheduledAt: import("spacetimedb").ScheduleAtBuilder;
+}>;
+export type GcJob = __Infer<typeof GcJob>;
+export declare const LogEntry: import("spacetimedb").ProductBuilder<{
+    id: import("spacetimedb").U64Builder;
+    flowId: import("spacetimedb").U64Builder;
+    level: import("spacetimedb").StringBuilder;
+    message: import("spacetimedb").StringBuilder;
+    data: import("spacetimedb").StringBuilder;
+    createdAt: import("spacetimedb").TimestampBuilder;
+}>;
+export type LogEntry = __Infer<typeof LogEntry>;

package/dist/module_bindings/update_error_group_status_reducer.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    keyHash: import("spacetimedb").StringBuilder;
+    errorGroupId: import("spacetimedb").U64Builder;
+    status: import("spacetimedb").StringBuilder;
+};
+export default _default;

package/package.json

@@ -1,20 +1,27 @@
 {
   "name": "@radishbot/sdk",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
   },
   "bin": {
     "radish": "./src/cli.ts"
   },
   "files": [
     "src",
+    "dist",
     "README.md"
   ],
   "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target node --format esm --external spacetimedb --external ws",
+    "prepublishOnly": "bun run build",
     "cli": "bun run ./src/cli.ts"
   },
   "dependencies": {