rivetkit 2.3.4 → 2.3.5-rc.1

package/dist/tsup/mod.js

@@ -1,6 +1,6 @@
 import {
   decodeWorkflowHistoryTransport
-} from "./chunk-GXW3VFJQ.js";
+} from "./chunk-MGTSVSUC.js";
 import {
   ACTOR_CONTEXT_INTERNAL_SYMBOL,
   ActorConfigSchema,
@@ -10,7 +10,7 @@ import {
   getRunFunction,
   getRunInspectorConfig,
   getRunMetadata
-} from "./chunk-XIX5DOZN.js";
+} from "./chunk-SHBE77IT.js";
 import {
   ALLOWED_PUBLIC_HEADERS,
   HEADER_CONN_PARAMS,
@@ -20,26 +20,21 @@ import {
   getDatacenters,
   tryParseEndpoint,
   updateRunnerConfig
-} from "./chunk-CMPFZ724.js";
+} from "./chunk-GAV4PKFT.js";
 import {
-  KEYS,
   makePrefixedKey,
-  queueMessagesPrefix,
-  queueMetadataKey,
-  removePrefixFromKey,
-  workflowStoragePrefix
-} from "./chunk-HXUEHHJF.js";
-import {
-  assertJsonCompatValue,
-  decodeCborCompat,
-  encodeCborCompat
-} from "./chunk-W6WPKZ6I.js";
-import "./chunk-EOSGY3DC.js";
+  removePrefixFromKey
+} from "./chunk-JI6GZ2C2.js";
+import "./chunk-7AFZMFPQ.js";
+import "./chunk-PAG6G46L.js";
 import {
   LogLevelSchema,
   VERSION,
+  assertJsonCompatValue,
   configureBaseLogger,
+  decodeCborCompat,
   deconstructError,
+  encodeCborCompat,
   getEnvUniversal,
   getLogger,
   getNodeEnv,
@@ -64,7 +59,7 @@ import {
   parsePortEnv,
   stringifyError,
   toUint8Array
-} from "./chunk-M7DCRMOZ.js";
+} from "./chunk-B4IZU537.js";
 import {
   INTERNAL_ERROR_CODE,
   RivetError,
@@ -77,7 +72,6 @@ import {
   toRivetError,
   unsupportedFeature
 } from "./chunk-ZZ3WBRPD.js";
-import "./chunk-JZ7TWV65.js";
 
 // src/actor/log.ts
 function loggerWithoutContext() {
@@ -85,15 +79,21 @@ function loggerWithoutContext() {
 }
 
 // src/actor/definition.ts
-var warnedDeprecatedTimeoutKeys = /* @__PURE__ */ new Set();
-function warnDeprecatedShutdownTimeoutKeys(options) {
+var warnedDeprecatedOptionKeys = /* @__PURE__ */ new Set();
+var DEPRECATED_OPTION_MESSAGES = {
+  onDestroyTimeout: "Configure `sleepGracePeriod` instead, which bounds the entire graceful shutdown window for both sleep and destroy.",
+  waitUntilTimeout: "Configure `sleepGracePeriod` instead, which bounds the entire graceful shutdown window for both sleep and destroy.",
+  preloadMaxWorkflowBytes: "Internal storage moved to SQLite and no longer uses KV preloading.",
+  preloadMaxConnectionsBytes: "Internal storage moved to SQLite and no longer uses KV preloading."
+};
+function warnDeprecatedOptionKeys(options) {
   if (!options || typeof options !== "object") return;
   const opts = options;
-  for (const key of ["onDestroyTimeout", "waitUntilTimeout"]) {
-    if (opts[key] !== void 0 && !warnedDeprecatedTimeoutKeys.has(key)) {
-      warnedDeprecatedTimeoutKeys.add(key);
+  for (const [key, detail] of Object.entries(DEPRECATED_OPTION_MESSAGES)) {
+    if (opts[key] !== void 0 && !warnedDeprecatedOptionKeys.has(key)) {
+      warnedDeprecatedOptionKeys.add(key);
       loggerWithoutContext().warn({
-        msg: `actor option \`${key}\` is deprecated and is now ignored. Configure \`sleepGracePeriod\` instead, which bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0.`
+        msg: `actor option \`${key}\` is deprecated and is now ignored. ${detail} Will be removed in 2.2.0.`
       });
     }
   }
@@ -111,7 +111,7 @@ function isStaticActorInstance(_actor) {
   return true;
 }
 function actor(input) {
-  warnDeprecatedShutdownTimeoutKeys(
+  warnDeprecatedOptionKeys(
     input == null ? void 0 : input.options
   );
   const config = ActorConfigSchema.parse(input);
@@ -839,31 +839,6 @@ function buildActorNames(config) {
       const metadata = {};
       metadata.icon = options.icon ?? runMeta.icon;
       metadata.name = options.name ?? runMeta.name;
-      metadata.preload = {
-        keys: [
-          Array.from(KEYS.PERSIST_DATA),
-          Array.from(KEYS.INSPECTOR_TOKEN),
-          Array.from(queueMetadataKey()),
-          Array.from(KEYS.LAST_PUSHED_ALARM)
-        ],
-        prefixes: [
-          {
-            prefix: Array.from(workflowStoragePrefix()),
-            maxBytes: options.preloadMaxWorkflowBytes ?? 131072,
-            partial: false
-          },
-          {
-            prefix: Array.from(KEYS.CONN_PREFIX),
-            maxBytes: options.preloadMaxConnectionsBytes ?? 65536,
-            partial: false
-          },
-          {
-            prefix: Array.from(queueMessagesPrefix()),
-            maxBytes: 65536,
-            partial: false
-          }
-        ]
-      };
       if (!metadata.icon) delete metadata.icon;
       if (!metadata.name) delete metadata.name;
       return [actorName, { metadata }];
@@ -1056,6 +1031,12 @@ function toNativeBindings(sql, params) {
     return toNativeBinding(value);
   });
 }
+function toNativeBatchStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: toNativeBindings(statement.sql, statement.params)
+  };
+}
 function normalizeNativeMetrics(metrics) {
   if (!metrics) return null;
   const raw = metrics;
@@ -1169,6 +1150,60 @@ function wrapJsNativeDatabase(database) {
     async execute(sql, params) {
       return await executeNative(sql, params);
     },
+    async executeBatch(statements) {
+      const nativeStatements = statements.map(toNativeBatchStatement);
+      const release = gate.enter();
+      let transaction;
+      try {
+        const results = database.executeBatch ? await database.executeBatch(nativeStatements) : await (async () => {
+          transaction = await database.beginTransaction();
+          const transactionResults = [];
+          for (const statement of nativeStatements) {
+            transactionResults.push(
+              await transaction.execute(
+                statement.sql,
+                statement.params
+              )
+            );
+          }
+          await transaction.commit();
+          transaction = void 0;
+          return transactionResults;
+        })();
+        for (const result of results) {
+          if (result.lastInsertRowId !== void 0) {
+            lastInsertRowId = result.lastInsertRowId;
+          }
+        }
+        return results;
+      } catch (error) {
+        if (transaction) {
+          try {
+            await transaction.rollback();
+          } catch {
+          }
+        }
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+    },
+    async beginTransaction(timeoutMs) {
+      const release = gate.enter();
+      let transaction;
+      try {
+        transaction = await database.beginTransaction(timeoutMs);
+      } catch (error) {
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+      return wrapTransaction(database, transaction, gate, (result) => {
+        if (result.lastInsertRowId !== void 0) {
+          lastInsertRowId = result.lastInsertRowId;
+        }
+      });
+    },
     async run(sql, params) {
       await executeNative(sql, params);
     },
@@ -1186,6 +1221,59 @@ function wrapJsNativeDatabase(database) {
     }
   };
 }
+function wrapTransaction(database, transaction, gate, onExecute) {
+  return {
+    async exec(sql, callback) {
+      const release = gate.enter();
+      let result;
+      try {
+        result = await transaction.exec(sql);
+      } catch (error) {
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+      if (callback) {
+        for (const row of result.rows) callback(row, result.columns);
+      }
+    },
+    async execute(sql, params) {
+      const release = gate.enter();
+      try {
+        const result = await transaction.execute(
+          sql,
+          toNativeBindings(sql, params)
+        );
+        onExecute(result);
+        return result;
+      } catch (error) {
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+    },
+    async commit() {
+      const release = gate.enter();
+      try {
+        await transaction.commit();
+      } catch (error) {
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+    },
+    async rollback() {
+      const release = gate.enter();
+      try {
+        await transaction.rollback();
+      } catch (error) {
+        enrichNativeDatabaseError(database, error);
+      } finally {
+        release();
+      }
+    }
+  };
+}
 function lastInsertRowIdColumnName(sql) {
   const match = sql.match(
     /^\s*SELECT\s+last_insert_rowid\s*\(\s*\)\s*(?:AS\s+("[^"]+"|`[^`]+`|\[[^\]]+\]|\w+))?\s*;?\s*$/i
@@ -1300,6 +1388,9 @@ function asNativeConn(handle) {
 function asNativeWebSocket(handle) {
   return handle;
 }
+function asNativeSqlTransaction(handle) {
+  return handle;
+}
 function asNativeCancellationToken(handle) {
   return handle;
 }
@@ -1329,6 +1420,12 @@ function toNapiSqlBindParams(params) {
   }
   return params.map((param) => toNapiSqlBindParam(param));
 }
+function toNapiSqlBatchStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: toNapiSqlBindParams(statement.params) ?? void 0
+  };
+}
 function toNapiBuffer(value) {
   return Buffer.from(value);
 }
@@ -1452,11 +1549,16 @@ var NapiCoreRuntime = class {
   createCancellationToken() {
     return new this.#bindings.CancellationToken();
   }
-  createTestActorContext(actorId, name, region) {
-    return new this.#bindings.ActorContext(
-      actorId,
-      name,
-      region
+  decodeInspectorRequest(bytes, advertisedVersion) {
+    return this.#bindings.decodeInspectorRequest(
+      toNapiBuffer(bytes),
+      advertisedVersion
+    );
+  }
+  encodeInspectorResponse(bytes, targetVersion) {
+    return this.#bindings.encodeInspectorResponse(
+      toNapiBuffer(bytes),
+      targetVersion
     );
   }
   cancellationTokenAborted(token) {
@@ -1520,6 +1622,14 @@ var NapiCoreRuntime = class {
       toNapiStateDeltaPayload(payload)
     );
   }
+  async actorSaveStateAndWorkflowBatch(ctx, writes) {
+    await asNativeActorContext(ctx).saveStateAndWorkflowBatch(
+      writes.map((write) => ({
+        key: toNapiBuffer(write.key),
+        value: toNapiBuffer(write.value)
+      }))
+    );
+  }
   actorId(ctx) {
     return asNativeActorContext(ctx).actorId();
   }
@@ -1626,6 +1736,33 @@ var NapiCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  async actorSqlExecuteBatch(ctx, statements) {
+    const results = await this.#actorSql(ctx).executeBatch(
+      statements.map(toNapiSqlBatchStatement)
+    );
+    return results.map(normalizeRuntimeSqlExecuteResult);
+  }
+  async actorSqlBeginTransaction(ctx, timeoutMs) {
+    return await this.#actorSql(ctx).beginTransaction(
+      timeoutMs
+    );
+  }
+  async actorSqlTransactionExec(transaction, sql) {
+    return await asNativeSqlTransaction(transaction).exec(sql);
+  }
+  async actorSqlTransactionExecute(transaction, sql, params) {
+    const result = await asNativeSqlTransaction(transaction).execute(
+      sql,
+      toNapiSqlBindParams(params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
+  async actorSqlTransactionCommit(transaction) {
+    await asNativeSqlTransaction(transaction).commit();
+  }
+  async actorSqlTransactionRollback(transaction) {
+    await asNativeSqlTransaction(transaction).rollback();
+  }
   async actorSqlQuery(ctx, sql, params) {
     return await this.#actorSql(ctx).query(
       sql,
@@ -1652,6 +1789,9 @@ var NapiCoreRuntime = class {
     this.#sql.delete(nativeCtx);
     await database.close();
   }
+  async actorRuntimeSocketProvision(ctx) {
+    return await asNativeActorContext(ctx).provisionActorRuntimeSocket();
+  }
   async actorQueueSend(ctx, name, body) {
     return toNapiQueueMessage(
       await asNativeActorContext(ctx).queue().send(name, toNapiBuffer(body))
@@ -1700,11 +1840,51 @@ var NapiCoreRuntime = class {
   async actorQueueReset(ctx) {
     await asNativeActorContext(ctx).queue().reset();
   }
-  actorScheduleAfter(ctx, durationMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().after(durationMs, actionName, toNapiBuffer(args));
+  async actorScheduleAfter(ctx, durationMs, actionName, args) {
+    return await asNativeActorContext(ctx).schedule().after(durationMs, actionName, toNapiBuffer(args));
+  }
+  async actorScheduleAt(ctx, timestampMs, actionName, args) {
+    return await asNativeActorContext(ctx).schedule().at(timestampMs, actionName, toNapiBuffer(args));
+  }
+  async actorScheduleCancel(ctx, id) {
+    return await asNativeActorContext(ctx).schedule().cancel(id);
+  }
+  async actorScheduleGet(ctx, id) {
+    return await asNativeActorContext(ctx).schedule().get(id) ?? void 0;
+  }
+  async actorScheduleList(ctx) {
+    return await asNativeActorContext(ctx).schedule().list();
+  }
+  async actorCronSet(ctx, name, expression, timezone, actionName, args, maxHistory) {
+    await asNativeActorContext(ctx).schedule().cronSet(
+      name,
+      expression,
+      timezone,
+      actionName,
+      toNapiBuffer(args),
+      maxHistory
+    );
+  }
+  async actorCronEvery(ctx, name, intervalMs, actionName, args, maxHistory) {
+    await asNativeActorContext(ctx).schedule().cronEvery(
+      name,
+      intervalMs,
+      actionName,
+      toNapiBuffer(args),
+      maxHistory
+    );
+  }
+  async actorCronGet(ctx, name) {
+    return await asNativeActorContext(ctx).schedule().cronGet(name) ?? void 0;
+  }
+  async actorCronList(ctx) {
+    return await asNativeActorContext(ctx).schedule().cronList();
+  }
+  async actorCronDelete(ctx, name) {
+    return await asNativeActorContext(ctx).schedule().cronDelete(name);
   }
-  actorScheduleAt(ctx, timestampMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().at(timestampMs, actionName, toNapiBuffer(args));
+  async actorCronHistory(ctx, name, limit) {
+    return await asNativeActorContext(ctx).schedule().cronHistory(name, limit);
   }
   connId(conn) {
     return asNativeConn(conn).id();
@@ -2111,6 +2291,13 @@ var WasmCoreRuntime = class {
   async actorSaveState(ctx, payload) {
     await callHandleAsync(asWasmActorContext(ctx), "saveState", payload);
   }
+  async actorSaveStateAndWorkflowBatch(ctx, writes) {
+    await callHandleAsync(
+      asWasmActorContext(ctx),
+      "saveStateAndWorkflowBatch",
+      writes
+    );
+  }
   actorId(ctx) {
     return callHandle(asWasmActorContext(ctx), "actorId");
   }
@@ -2257,6 +2444,38 @@ var WasmCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  async actorSqlExecuteBatch(ctx, statements) {
+    const results = await callWasm(
+      () => this.#actorSql(ctx).executeBatch(statements)
+    );
+    return results.map(normalizeRuntimeSqlExecuteResult);
+  }
+  async actorSqlBeginTransaction(ctx, timeoutMs) {
+    return await callWasm(
+      () => this.#actorSql(ctx).beginTransaction(timeoutMs)
+    );
+  }
+  async actorSqlTransactionExec(transaction, sql) {
+    return await callWasm(
+      () => transaction.exec(sql)
+    );
+  }
+  async actorSqlTransactionExecute(transaction, sql, params) {
+    const result = await callWasm(
+      () => transaction.execute(sql, params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
+  async actorSqlTransactionCommit(transaction) {
+    await callWasm(
+      () => transaction.commit()
+    );
+  }
+  async actorSqlTransactionRollback(transaction) {
+    await callWasm(
+      () => transaction.rollback()
+    );
+  }
   async actorSqlQuery(ctx, sql, params) {
     return await callWasm(() => this.#actorSql(ctx).query(sql, params));
   }
@@ -2280,6 +2499,17 @@ var WasmCoreRuntime = class {
     this.#sql.delete(wasmCtx);
     await callWasm(() => database.close());
   }
+  async actorRuntimeSocketProvision(_ctx) {
+    throw new RivetError(
+      "actor_runtime_socket",
+      "unsupported",
+      "Actor Runtime Socket is only available on Unix native runtimes.",
+      {
+        public: true,
+        metadata: { runtime: "wasm" }
+      }
+    );
+  }
   async actorQueueSend(ctx, name, body) {
     const queue2 = childHandle(asWasmActorContext(ctx), "queue");
     return normalizeQueueMessage(
@@ -2351,13 +2581,97 @@ var WasmCoreRuntime = class {
     const queue2 = childHandle(asWasmActorContext(ctx), "queue");
     await callHandleAsync(queue2, "reset");
   }
-  actorScheduleAfter(ctx, durationMs, actionName, args) {
+  async actorScheduleAfter(ctx, durationMs, actionName, args) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "after",
+      wasmNumber(durationMs),
+      actionName,
+      args
+    );
+  }
+  async actorScheduleAt(ctx, timestampMs, actionName, args) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "at",
+      wasmNumber(timestampMs),
+      actionName,
+      args
+    );
+  }
+  async actorScheduleCancel(ctx, id) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(schedule, "cancel", id);
+  }
+  async actorScheduleGet(ctx, id) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "get",
+      id
+    );
+  }
+  async actorScheduleList(ctx) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "list"
+    );
+  }
+  async actorCronSet(ctx, name, expression, timezone, actionName, args, maxHistory) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    await callHandleAsync(
+      schedule,
+      "cronSet",
+      name,
+      expression,
+      timezone,
+      actionName,
+      args,
+      maxHistory
+    );
+  }
+  async actorCronEvery(ctx, name, intervalMs, actionName, args, maxHistory) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    await callHandleAsync(
+      schedule,
+      "cronEvery",
+      name,
+      intervalMs,
+      actionName,
+      args,
+      maxHistory
+    );
+  }
+  async actorCronGet(ctx, name) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "cronGet",
+      name
+    );
+  }
+  async actorCronList(ctx) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "cronList"
+    );
+  }
+  async actorCronDelete(ctx, name) {
     const schedule = childHandle(asWasmActorContext(ctx), "schedule");
-    callHandle(schedule, "after", wasmNumber(durationMs), actionName, args);
+    return await callHandleAsync(schedule, "cronDelete", name);
   }
-  actorScheduleAt(ctx, timestampMs, actionName, args) {
+  async actorCronHistory(ctx, name, limit) {
     const schedule = childHandle(asWasmActorContext(ctx), "schedule");
-    callHandle(schedule, "at", wasmNumber(timestampMs), actionName, args);
+    return await callHandleAsync(
+      schedule,
+      "cronHistory",
+      name,
+      limit
+    );
   }
   connId(conn) {
     return callHandle(asWasmConn(conn), "id");
@@ -2697,6 +3011,23 @@ function getOrCreateNativeSqlDatabase(runtime, ctx) {
   const database = wrapJsNativeDatabase({
     exec: (sql) => runtime.actorSqlExec(ctx, sql),
     execute: (sql, params) => runtime.actorSqlExecute(ctx, sql, params),
+    executeBatch: (statements) => runtime.actorSqlExecuteBatch(ctx, statements),
+    beginTransaction: async (timeoutMs) => {
+      const transaction = await runtime.actorSqlBeginTransaction(
+        ctx,
+        timeoutMs
+      );
+      return {
+        exec: (sql) => runtime.actorSqlTransactionExec(transaction, sql),
+        execute: (sql, params) => runtime.actorSqlTransactionExecute(
+          transaction,
+          sql,
+          params
+        ),
+        commit: () => runtime.actorSqlTransactionCommit(transaction),
+        rollback: () => runtime.actorSqlTransactionRollback(transaction)
+      };
+    },
     query: (sql, params) => runtime.actorSqlQuery(ctx, sql, params),
     run: (sql, params) => runtime.actorSqlRun(ctx, sql, params),
     metrics: () => runtime.actorSqlMetrics(ctx),
@@ -3190,26 +3521,116 @@ var NativeScheduleAdapter = class {
     this.#ctx = ctx;
   }
   async after(duration, action, ...args) {
-    callNativeSync(
-      () => this.#runtime.actorScheduleAfter(
-        this.#ctx,
-        duration,
-        action,
-        encodeValue(args)
-      )
+    return await this.#runtime.actorScheduleAfter(
+      this.#ctx,
+      duration,
+      action,
+      encodeValue(args)
     );
   }
   async at(timestamp, action, ...args) {
-    callNativeSync(
-      () => this.#runtime.actorScheduleAt(
-        this.#ctx,
-        timestamp,
-        action,
-        encodeValue(args)
-      )
+    return await this.#runtime.actorScheduleAt(
+      this.#ctx,
+      timestamp,
+      action,
+      encodeValue(args)
+    );
+  }
+  async cancel(id) {
+    return await this.#runtime.actorScheduleCancel(this.#ctx, id);
+  }
+  async get(id) {
+    const event2 = await this.#runtime.actorScheduleGet(this.#ctx, id);
+    return event2 ? decodeScheduledEventInfo(event2) : void 0;
+  }
+  async list() {
+    return (await this.#runtime.actorScheduleList(this.#ctx)).map(
+      decodeScheduledEventInfo
+    );
+  }
+};
+var NativeCronAdapter = class {
+  #runtime;
+  #ctx;
+  constructor(runtime, ctx) {
+    this.#runtime = runtime;
+    this.#ctx = ctx;
+  }
+  async set(options) {
+    await this.#runtime.actorCronSet(
+      this.#ctx,
+      options.name,
+      options.expression,
+      options.timezone,
+      options.action,
+      encodeValue(options.args ?? []),
+      options.maxHistory
     );
   }
+  async every(options) {
+    await this.#runtime.actorCronEvery(
+      this.#ctx,
+      options.name,
+      options.interval,
+      options.action,
+      encodeValue(options.args ?? []),
+      options.maxHistory
+    );
+  }
+  async get(name) {
+    const job = await this.#runtime.actorCronGet(this.#ctx, name);
+    return job ? decodeCronJobInfo(job) : void 0;
+  }
+  async list() {
+    return (await this.#runtime.actorCronList(this.#ctx)).map(
+      decodeCronJobInfo
+    );
+  }
+  async delete(name) {
+    return await this.#runtime.actorCronDelete(this.#ctx, name);
+  }
+  async history(name, options) {
+    return (await this.#runtime.actorCronHistory(
+      this.#ctx,
+      name,
+      options == null ? void 0 : options.limit
+    )).map(decodeCronFire);
+  }
 };
+function decodeScheduledEventInfo(event2) {
+  return {
+    id: event2.id,
+    action: event2.action,
+    args: decodeArgs(event2.args),
+    runAt: event2.runAt
+  };
+}
+function decodeCronJobInfo(job) {
+  const base = {
+    name: job.name,
+    action: job.action,
+    args: decodeArgs(job.args),
+    nextRunAt: job.nextRunAt,
+    lastRunAt: job.lastRunAt,
+    maxHistory: job.maxHistory
+  };
+  if (job.kind === "cron") {
+    return {
+      ...base,
+      kind: "cron",
+      expression: job.expression,
+      timezone: job.timezone
+    };
+  }
+  return {
+    ...base,
+    kind: "every",
+    interval: job.intervalMs
+  };
+}
+function decodeCronFire(fire) {
+  return { ...fire };
+}
 var NativeKvAdapter = class {
   #runtime;
   #ctx;
@@ -3990,6 +4411,7 @@ var ActorContextHandleAdapter = class {
   #client;
   #clientFactory;
   #connMap;
+  #cron;
   #databaseProvider;
   #db;
   #dispatchCancelToken;
@@ -4030,6 +4452,11 @@ var ActorContextHandleAdapter = class {
     }
     return this.#sql;
   }
+  async actorRuntimeSocket() {
+    return await callNative(
+      () => this.#runtime.actorRuntimeSocketProvision(this.#ctx)
+    );
+  }
   get db() {
     if (!this.#databaseProvider) {
       throw databaseNotConfiguredError();
@@ -4119,6 +4546,12 @@ var ActorContextHandleAdapter = class {
     }
     return this.#schedule;
   }
+  get cron() {
+    if (!this.#cron) {
+      this.#cron = new NativeCronAdapter(this.#runtime, this.#ctx);
+    }
+    return this.#cron;
+  }
   get actorId() {
     return callNativeSync(() => this.#runtime.actorId(this.#ctx));
   }
@@ -4303,6 +4736,11 @@ var ActorContextHandleAdapter = class {
       () => this.#runtime.actorRequestSave(this.#ctx, { immediate: false })
     );
   }
+  async saveStateAndWorkflowBatch(writes) {
+    await callNative(
+      () => this.#runtime.actorSaveStateAndWorkflowBatch(this.#ctx, writes)
+    );
+  }
   serializeForTick(reason) {
     void reason;
     const actorState = getNativePersistState(this.#runtime, this.#ctx);
@@ -4617,6 +5055,9 @@ var NativeWorkflowRuntimeAdapter = class {
     this.stateManager = {
       saveState: async (opts) => {
         await this.#ctx.saveState(opts);
+      },
+      saveStateAndWorkflowBatch: async (writes) => {
+        await this.#ctx.saveStateAndWorkflowBatch(writes);
       }
     };
   }
@@ -4686,11 +5127,13 @@ function buildActorConfig(definition, registryConfig, runtimeKind) {
   const config = definition.config;
   const options = config.options ?? {};
   const canHibernate = options.canHibernateWebSocket;
+  const usesRemoteSqlite = sqliteBackendForConfig(registryConfig) === "remote";
   return {
     name: options.name,
     icon: options.icon,
-    hasDatabase: config.db !== void 0,
-    remoteSqlite: config.db !== void 0 && sqliteBackendForConfig(registryConfig) === "remote",
+    hasDatabase: config.db !== void 0 || usesRemoteSqlite,
+    remoteSqlite: usesRemoteSqlite,
+    enableActorRuntimeSocket: options.enableActorRuntimeSocket === true,
     hasState: config.state !== void 0 || typeof config.createState === "function",
     canHibernateWebsocket: typeof canHibernate === "boolean" ? canHibernate : void 0,
     stateSaveIntervalMs: options.stateSaveInterval,
@@ -4706,6 +5149,7 @@ function buildActorConfig(definition, registryConfig, runtimeKind) {
     connectionLivenessTimeoutMs: options.connectionLivenessTimeout,
     connectionLivenessIntervalMs: options.connectionLivenessInterval,
     maxQueueSize: options.maxQueueSize,
+    maxSchedules: options.maxSchedules,
     maxQueueMessageSize: options.maxQueueMessageSize,
     maxIncomingMessageSize: registryConfig.maxIncomingMessageSize,
     maxOutgoingMessageSize: registryConfig.maxOutgoingMessageSize,
@@ -4982,7 +5426,9 @@ function buildNativeFactory(runtime, registryConfig, definition) {
             400
           );
         }
-        const cbor = encodeCborCompat(body.body ?? null);
+        const cbor = encodeCborCompat(
+          body.body ?? null
+        );
         const message = await runtime.actorQueueSend(ctx, name, cbor);
         return jsonResponse({
           id: message.id().toString(),
@@ -5675,7 +6121,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
         name,
         wrapNativeCallback(
           async (error, payload) => {
-            const { ctx, conn, args, cancelToken } = unwrapTsfnPayload(error, payload);
+            const { ctx, conn, args, scheduledFire, cancelToken } = unwrapTsfnPayload(error, payload);
             const actorCtx = conn != null ? makeConnCtx(ctx, conn, void 0, cancelToken) : makeActorCtx(ctx, void 0, cancelToken);
             try {
               return encodeValue(
@@ -5685,7 +6131,8 @@ function buildNativeFactory(runtime, registryConfig, definition) {
                     schemaConfig.actionInputSchemas,
                     name,
                     decodeArgs(args)
-                  )
+                  ),
+                  ...scheduledFire ? [scheduledFire] : []
                 )
               );
             } finally {