@rivetkit/supabase 0.0.0-stack-chore-sync-engine-changes-from-enterprise-mszropyy.677d526 → 0.0.0-sync-sqlite.0ed739a

package/dist/mod.mjs

@@ -481,7 +481,7 @@ function unsupportedFeature(feature) {
   );
 }
 
-// ../rivetkit/dist/tsup/chunk-GPD77M3M.js
+// ../rivetkit/dist/tsup/chunk-NNPIJLBE.js
 import {
   pino,
   stdTimeFunctions
@@ -13157,7 +13157,7 @@ var classic_default = external_exports;
 // ../../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/index.js
 var v4_default = classic_default;
 
-// ../rivetkit/dist/tsup/chunk-GPD77M3M.js
+// ../rivetkit/dist/tsup/chunk-NNPIJLBE.js
 var import_invariant = __toESM(require_invariant(), 1);
 import * as cbor from "cbor-x";
 var getRivetEngine = () => getEnvUniversal("RIVET_ENGINE");
@@ -13331,7 +13331,7 @@ function noopNext() {
 }
 var package_default = {
   name: "rivetkit",
-  version: "0.0.0-stack-chore-sync-engine-changes-from-enterprise-mszropyy.677d526",
+  version: "0.0.0-sync-sqlite.0ed739a",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -14635,7 +14635,7 @@ function Config({ initialBufferLength = 1024, maxBufferLength = 1024 * 1024 * 32
   };
 }
 
-// ../rivetkit/dist/tsup/chunk-M4RSGECU.js
+// ../rivetkit/dist/tsup/chunk-EHAGZJ34.js
 var config2 = /* @__PURE__ */ Config({});
 function readWorkflowCbor(bc) {
   return readData(bc);
@@ -15514,45 +15514,7 @@ function removePrefixFromKey(prefixedKey) {
   return prefixedKey.slice(KEYS.KV.length);
 }
 
-// ../rivetkit/dist/tsup/chunk-L6DNN72S.js
-function logger() {
-  return getLogger("actor-client");
-}
-var webSocketPromise = null;
-async function importWebSocket() {
-  if (webSocketPromise !== null) {
-    return webSocketPromise;
-  }
-  webSocketPromise = (async () => {
-    let _WebSocket;
-    if (typeof WebSocket !== "undefined") {
-      _WebSocket = WebSocket;
-    } else {
-      try {
-        const moduleName = "ws";
-        const ws = await import(
-          /* webpackIgnore: true */
-          moduleName
-        );
-        _WebSocket = ws.default;
-        logger().debug("using websocket from npm");
-      } catch {
-        _WebSocket = class MockWebSocket {
-          constructor() {
-            throw new Error(
-              'WebSocket support requires installing the "ws" peer dependency.'
-            );
-          }
-        };
-        logger().debug("using mock websocket");
-      }
-    }
-    return _WebSocket;
-  })();
-  return webSocketPromise;
-}
-
-// ../rivetkit/dist/tsup/chunk-JTHHCZCZ.js
+// ../rivetkit/dist/tsup/chunk-WCEJTJHO.js
 var MIGRATION_TRANSACTION_TIMEOUT_MS = 5 * 6e4;
 function isManualTransactionControl(query) {
   return /^\s*(?:BEGIN|SAVEPOINT|COMMIT|END|ROLLBACK)\b/i.test(query);
@@ -15572,6 +15534,38 @@ function validateTransactionName(name) {
     throw new Error("db.transaction() name must not be empty");
   }
 }
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function" ? typeof value.then === "function" : false;
+}
+function runSqliteTransactionSync(database, callback, options) {
+  validateTransactionTimeout(options == null ? void 0 : options.timeout);
+  validateTransactionName(options == null ? void 0 : options.name);
+  if (!database.beginTransactionSync) {
+    throw new Error(
+      "Synchronous SQLite transactions are only available in the Node.js native runtime."
+    );
+  }
+  const transaction = database.beginTransactionSync(
+    options == null ? void 0 : options.timeout,
+    options == null ? void 0 : options.name
+  );
+  try {
+    const result = callback(transaction);
+    if (isPromiseLike(result)) {
+      throw new Error(
+        "db.transactionSync() callback must complete synchronously and must not return a promise."
+      );
+    }
+    transaction.commitSync();
+    return result;
+  } catch (error46) {
+    try {
+      transaction.rollbackSync();
+    } catch {
+    }
+    throw error46;
+  }
+}
 function isSqliteBindingValue(value) {
   if (value === null || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || value instanceof Uint8Array) {
     return true;
@@ -15635,7 +15629,45 @@ var AsyncMutex = class {
   }
 };
 
-// ../rivetkit/dist/tsup/chunk-OWSXJF7Z.js
+// ../rivetkit/dist/tsup/chunk-SLAKWYOH.js
+function logger() {
+  return getLogger("actor-client");
+}
+var webSocketPromise = null;
+async function importWebSocket() {
+  if (webSocketPromise !== null) {
+    return webSocketPromise;
+  }
+  webSocketPromise = (async () => {
+    let _WebSocket;
+    if (typeof WebSocket !== "undefined") {
+      _WebSocket = WebSocket;
+    } else {
+      try {
+        const moduleName = "ws";
+        const ws = await import(
+          /* webpackIgnore: true */
+          moduleName
+        );
+        _WebSocket = ws.default;
+        logger().debug("using websocket from npm");
+      } catch {
+        _WebSocket = class MockWebSocket {
+          constructor() {
+            throw new Error(
+              'WebSocket support requires installing the "ws" peer dependency.'
+            );
+          }
+        };
+        logger().debug("using mock websocket");
+      }
+    }
+    return _WebSocket;
+  })();
+  return webSocketPromise;
+}
+
+// ../rivetkit/dist/tsup/chunk-BERJKIW5.js
 var import_invariant2 = __toESM(require_invariant(), 1);
 
 // ../../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
@@ -15813,7 +15845,7 @@ function createVersionedDataHandler(config3) {
   return new VersionedDataHandler(config3);
 }
 
-// ../rivetkit/dist/tsup/chunk-OWSXJF7Z.js
+// ../rivetkit/dist/tsup/chunk-BERJKIW5.js
 var import_invariant3 = __toESM(require_invariant(), 1);
 var import_invariant4 = __toESM(require_invariant(), 1);
 var PATH_CONNECT = "/connect";
@@ -18318,6 +18350,15 @@ function createQueueSender(senderOptions) {
     send
   };
 }
+async function prepareRetryableInit(init) {
+  if (init.body instanceof ReadableStream) {
+    return {
+      ...init,
+      body: new Uint8Array(await new Response(init.body).arrayBuffer())
+    };
+  }
+  return init;
+}
 async function rawHttpFetch(driver, target, params, input, init, options = {}) {
   let path2;
   let originalUrl;
@@ -18852,9 +18893,10 @@ var ActorHandleRaw = class {
     return this.#fetchWithResolvedActor(input, init);
   }
   async #fetchWithResolvedActor(input, init) {
-    const { skipReadyWait, ...requestInit } = init ?? {};
-    const hasBody = requestInit.body !== void 0 ? requestInit.body !== null : isRequestLike(input) && input.body !== null;
-    const maxAttempts = hasBody ? 1 : this.#getDynamicQueryMaxAttempts();
+    const { skipReadyWait, ...restInit } = init ?? {};
+    const maxAttempts = this.#getDynamicQueryMaxAttempts();
+    const requestInit = maxAttempts > 1 ? await prepareRetryableInit(restInit) : restInit;
+    const clonesInputBody = requestInit.body === void 0 && isRequestLike(input) && input.body !== null;
     let useQueryTarget = isDynamicActorQuery(this.#actorResolutionState);
     const gatewayOptions = resolveActorGatewayOptions(
       this.#gatewayOptions,
@@ -18874,7 +18916,9 @@ var ActorHandleRaw = class {
           this.#driver,
           target,
           this.#params,
-          input,
+          // Clone a body-bearing Request so retries don't reuse a consumed stream.
+          // NOTE: This holds the body in memory until GC (unavoidable).
+          clonesInputBody ? input.clone() : input,
           requestInit,
           gatewayOptions
         );
@@ -21585,7 +21629,7 @@ function apiActorToOutput(actor2) {
   };
 }
 
-// ../rivetkit/dist/tsup/chunk-LHT3TRDM.js
+// ../rivetkit/dist/tsup/chunk-J7WM3KL5.js
 var nativeStateTransactionOpeners = /* @__PURE__ */ new WeakMap();
 var nativeStateTransactionClientBinders = /* @__PURE__ */ new WeakMap();
 function registerNativeStateTransactionOpener(provider, opener) {
@@ -21620,6 +21664,7 @@ function db({
       const db2 = await nativeDatabaseProvider.open(ctx.actorId);
       let closed = false;
       let manualTransactionWarned = false;
+      let synchronousTransactionActive = false;
       const ensureOpen = () => {
         if (closed) {
           throw new Error(
@@ -21627,16 +21672,24 @@ function db({
           );
         }
       };
+      const ensureSynchronousTransactionClient = (transactionScoped) => {
+        if (!transactionScoped && synchronousTransactionActive) {
+          throw new Error(
+            "Use the transaction callback's tx value for queries inside db.transactionSync()."
+          );
+        }
+      };
       const createClient = (target, transactionScoped = false, stateTransactionContext) => {
         const client2 = {
           execute: async (query, ...args) => {
             var _a2, _b, _c, _d;
             ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
             if (!transactionScoped && warnOnManualTransactions && !manualTransactionWarned && !hasMultipleStatements(query) && isManualTransactionControl(query)) {
               manualTransactionWarned = true;
               getLogger("database").warn(
                 { actorId: ctx.actorId },
-                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
+                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
               );
             }
             const kvReadsBefore = ((_a2 = ctx.metrics) == null ? void 0 : _a2.totalKvReads) ?? 0;
@@ -21682,8 +21735,66 @@ function db({
               }
             }
           },
+          executeSync: (query, ...args) => {
+            var _a2, _b, _c, _d;
+            ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
+            if (!target.executeSync) {
+              throw new Error(
+                "Synchronous SQLite queries are only available in the Node.js native runtime."
+              );
+            }
+            if (!transactionScoped && warnOnManualTransactions && !manualTransactionWarned && !hasMultipleStatements(query) && isManualTransactionControl(query)) {
+              manualTransactionWarned = true;
+              getLogger("database").warn(
+                { actorId: ctx.actorId },
+                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
+              );
+            }
+            const kvReadsBefore = ((_a2 = ctx.metrics) == null ? void 0 : _a2.totalKvReads) ?? 0;
+            const kvWritesBefore = ((_b = ctx.metrics) == null ? void 0 : _b.totalKvWrites) ?? 0;
+            const start = performance.now();
+            try {
+              if (args.length > 0) {
+                const bindings = args.length === 1 && isSqliteBindingObject(args[0]) ? toSqliteBindings(args[0]) : toSqliteBindings(args);
+                const { rows, columns } = target.executeSync(
+                  query,
+                  bindings
+                );
+                return rows.map(
+                  (row) => rowToObject(row, columns)
+                );
+              }
+              if (!hasMultipleStatements(query)) {
+                const { rows, columns } = target.executeSync(
+                  query,
+                  void 0
+                );
+                return rows.map(
+                  (row) => rowToObject(row, columns)
+                );
+              }
+              return execMultiStatementSync(target, query);
+            } finally {
+              const durationMs = performance.now() - start;
+              (_c = ctx.metrics) == null ? void 0 : _c.trackSql(query, durationMs);
+              if (ctx.metrics) {
+                const kvReads = ctx.metrics.totalKvReads - kvReadsBefore;
+                const kvWrites = ctx.metrics.totalKvWrites - kvWritesBefore;
+                (_d = ctx.log) == null ? void 0 : _d.debug({
+                  msg: "sql query",
+                  query: query.slice(0, 120),
+                  durationMs,
+                  kvReads,
+                  kvWrites
+                });
+              }
+            }
+          },
           transaction: async (callback, options) => {
             var _a2, _b;
+            ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
             validateTransactionTimeout(options == null ? void 0 : options.timeout);
             validateTransactionName(options == null ? void 0 : options.name);
             if (transactionScoped && ((_a2 = options == null ? void 0 : options.experimental) == null ? void 0 : _a2.includeState)) {
@@ -21729,6 +21840,33 @@ function db({
               }
             }
           },
+          transactionSync: (callback, options) => {
+            ensureOpen();
+            if (transactionScoped || synchronousTransactionActive) {
+              throw new Error(
+                "Nested synchronous SQLite transactions are not supported."
+              );
+            }
+            return runSqliteTransactionSync(
+              db2,
+              (transaction) => {
+                const transactionClient = createClient(
+                  transaction,
+                  true
+                );
+                const tx = {
+                  executeSync: transactionClient.executeSync
+                };
+                synchronousTransactionActive = true;
+                try {
+                  return callback(tx);
+                } finally {
+                  synchronousTransactionActive = false;
+                }
+              },
+              options
+            );
+          },
           close: async () => {
             if (!closed) {
               closed = true;
@@ -21780,6 +21918,22 @@ async function execMultiStatement(db2, query) {
   });
   return results;
 }
+function execMultiStatementSync(db2, query) {
+  if (!db2.execSync) {
+    throw new Error(
+      "Synchronous SQLite queries are only available in the Node.js native runtime."
+    );
+  }
+  const results = [];
+  let columnNames = null;
+  db2.execSync(query, (row, columns) => {
+    if (!columnNames) {
+      columnNames = columns;
+    }
+    results.push(rowToObject(row, columnNames));
+  });
+  return results;
+}
 async function withMigrationSavepoint(client, callback) {
   return await client.transaction(
     async (transaction) => {
@@ -23152,7 +23306,7 @@ function getValidationSchema(schema) {
   }
   return schema;
 }
-function isPromiseLike(value) {
+function isPromiseLike2(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function validateSchemaSync(schemas, key, data) {
@@ -23162,7 +23316,7 @@ function validateSchemaSync(schemas, key, data) {
   }
   if (isStandardSchema(schema)) {
     const result = schema["~standard"].validate(data);
-    if (isPromiseLike(result)) {
+    if (isPromiseLike2(result)) {
       throw unsupportedFeature("async schema validation");
     }
     if (result.issues) {
@@ -23894,6 +24048,10 @@ var DocRegistryConfigSchema = external_exports.object({
   serverless: DocServerlessConfigSchema.optional(),
   envoy: DocEnvoyConfigSchema.optional()
 }).describe("RivetKit registry configuration.");
+function isSynchronousTransaction(transaction) {
+  const candidate = transaction;
+  return typeof candidate.commitSync === "function" && typeof candidate.rollbackSync === "function";
+}
 function shouldAttachNativeKvError(message) {
   return /i\/o error|unable to open database file/i.test(message);
 }
@@ -24081,6 +24239,30 @@ function wrapJsNativeDatabase(database) {
       release();
     }
   };
+  const executeNativeSync = (sql, params) => {
+    const lastInsertRowIdColumn = lastInsertRowIdColumnName(sql);
+    if (lastInsertRowIdColumn) {
+      return {
+        columns: [lastInsertRowIdColumn],
+        rows: [[lastInsertRowId ?? 0]],
+        changes: 0,
+        lastInsertRowId
+      };
+    }
+    const release = gate.enter();
+    try {
+      const nativeParams = toNativeBindings(sql, params);
+      const result = database.executeSync(sql, nativeParams);
+      if (result.lastInsertRowId !== void 0) {
+        lastInsertRowId = result.lastInsertRowId;
+      }
+      return result;
+    } catch (error46) {
+      enrichNativeDatabaseError(database, error46);
+    } finally {
+      release();
+    }
+  };
   return {
     async exec(sql, callback) {
       const release = gate.enter();
@@ -24099,9 +24281,28 @@ function wrapJsNativeDatabase(database) {
         callback(row, result.columns);
       }
     },
+    execSync(sql, callback) {
+      const release = gate.enter();
+      let result;
+      try {
+        result = database.execSync(sql);
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+      if (callback) {
+        for (const row of result.rows) {
+          callback(row, result.columns);
+        }
+      }
+    },
     async execute(sql, params) {
       return await executeNative(sql, params);
     },
+    executeSync(sql, params) {
+      return executeNativeSync(sql, params);
+    },
     async executeBatch(statements) {
       const nativeStatements = statements.map(toNativeBatchStatement);
       const release = gate.enter();
@@ -24156,6 +24357,22 @@ function wrapJsNativeDatabase(database) {
         }
       });
     },
+    beginTransactionSync(timeoutMs, name) {
+      const release = gate.enter();
+      let transaction;
+      try {
+        transaction = database.beginTransactionSync(timeoutMs, name);
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+      return wrapTransaction(database, transaction, gate, (result) => {
+        if (result.lastInsertRowId !== void 0) {
+          lastInsertRowId = result.lastInsertRowId;
+        }
+      });
+    },
     async beginStateTransaction(timeoutMs, context) {
       if (!database.beginStateTransaction) {
         throw new Error("actor state transactions are not configured");
@@ -24196,7 +24413,7 @@ function wrapJsNativeDatabase(database) {
   };
 }
 function wrapTransaction(database, transaction, gate, onExecute) {
-  return {
+  const wrapped = {
     async exec(sql, callback) {
       const release = gate.enter();
       let result;
@@ -24211,6 +24428,20 @@ function wrapTransaction(database, transaction, gate, onExecute) {
         for (const row of result.rows) callback(row, result.columns);
       }
     },
+    execSync(sql, callback) {
+      const release = gate.enter();
+      let result;
+      try {
+        result = transaction.execSync(sql);
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+      if (callback) {
+        for (const row of result.rows) callback(row, result.columns);
+      }
+    },
     async execute(sql, params) {
       const release = gate.enter();
       try {
@@ -24226,6 +24457,21 @@ function wrapTransaction(database, transaction, gate, onExecute) {
         release();
       }
     },
+    executeSync(sql, params) {
+      const release = gate.enter();
+      try {
+        const result = transaction.executeSync(
+          sql,
+          toNativeBindings(sql, params)
+        );
+        onExecute(result);
+        return result;
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+    },
     async commit() {
       const release = gate.enter();
       try {
@@ -24247,6 +24493,31 @@ function wrapTransaction(database, transaction, gate, onExecute) {
       }
     }
   };
+  if (isSynchronousTransaction(transaction)) {
+    return Object.assign(wrapped, {
+      commitSync() {
+        const release = gate.enter();
+        try {
+          transaction.commitSync();
+        } catch (error46) {
+          enrichNativeDatabaseError(database, error46);
+        } finally {
+          release();
+        }
+      },
+      rollbackSync() {
+        const release = gate.enter();
+        try {
+          transaction.rollbackSync();
+        } catch (error46) {
+          enrichNativeDatabaseError(database, error46);
+        } finally {
+          release();
+        }
+      }
+    });
+  }
+  return wrapped;
 }
 function lastInsertRowIdColumnName(sql) {
   const match = sql.match(
@@ -24740,6 +25011,9 @@ var NapiCoreRuntime = class {
   async actorSqlExec(ctx, sql) {
     return await this.#actorSql(ctx).exec(sql);
   }
+  actorSqlExecSync(ctx, sql) {
+    return this.#actorSql(ctx).execSync(sql);
+  }
   async actorSqlExecute(ctx, sql, params) {
     const result = await this.#actorSql(ctx).execute(
       sql,
@@ -24747,6 +25021,13 @@ var NapiCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorSqlExecuteSync(ctx, sql, params) {
+    const result = this.#actorSql(ctx).executeSync(
+      sql,
+      toNapiSqlBindParams(params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
   async actorSqlExecuteBatch(ctx, statements) {
     const results = await this.#actorSql(ctx).executeBatch(
       statements.map(toNapiSqlBatchStatement)
@@ -24759,9 +25040,18 @@ var NapiCoreRuntime = class {
       name
     );
   }
+  actorSqlBeginTransactionSync(ctx, timeoutMs, name) {
+    return this.#actorSql(ctx).beginTransactionSync(
+      timeoutMs,
+      name
+    );
+  }
   async actorSqlTransactionExec(transaction, sql) {
     return await asNativeSqlTransaction(transaction).exec(sql);
   }
+  actorSqlTransactionExecSync(transaction, sql) {
+    return asNativeSqlTransaction(transaction).execSync(sql);
+  }
   async actorSqlTransactionExecute(transaction, sql, params) {
     const result = await asNativeSqlTransaction(transaction).execute(
       sql,
@@ -24769,12 +25059,25 @@ var NapiCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorSqlTransactionExecuteSync(transaction, sql, params) {
+    const result = asNativeSqlTransaction(transaction).executeSync(
+      sql,
+      toNapiSqlBindParams(params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
   async actorSqlTransactionCommit(transaction) {
     await asNativeSqlTransaction(transaction).commit();
   }
+  actorSqlTransactionCommitSync(transaction) {
+    asNativeSqlTransaction(transaction).commitSync();
+  }
   async actorSqlTransactionRollback(transaction) {
     await asNativeSqlTransaction(transaction).rollback();
   }
+  actorSqlTransactionRollbackSync(transaction) {
+    asNativeSqlTransaction(transaction).rollbackSync();
+  }
   async actorBeginStateTransaction(ctx, timeoutMs) {
     return await asNativeActorContext(ctx).beginStateTransaction(
       timeoutMs
@@ -24787,6 +25090,13 @@ var NapiCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorStateTransactionExecuteSync(transaction, sql, params) {
+    const result = asNativeActorStateTransaction(transaction).executeSync(
+      sql,
+      toNapiSqlBindParams(params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
   async actorStateTransactionCommit(transaction, payload) {
     await asNativeActorStateTransaction(transaction).commit(
       toNapiStateDeltaPayload(payload)
@@ -25386,6 +25696,11 @@ function optionalWasmNumber(value) {
 function wasmNumber(value) {
   return typeof value === "bigint" ? Number(value) : value;
 }
+function synchronousSqliteUnavailable() {
+  throw new Error(
+    "Synchronous SQLite operations are only available in the Node.js native runtime."
+  );
+}
 function normalizeKvEntry(entry) {
   return {
     key: toBytes(entry.key),
@@ -25789,12 +26104,18 @@ var WasmCoreRuntime = class {
   async actorSqlExec(ctx, sql) {
     return await callWasm(() => this.#actorSql(ctx).exec(sql));
   }
+  actorSqlExecSync(_ctx, _sql) {
+    return synchronousSqliteUnavailable();
+  }
   async actorSqlExecute(ctx, sql, params) {
     const result = await callWasm(
       () => this.#actorSql(ctx).execute(sql, params)
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorSqlExecuteSync(_ctx, _sql, _params) {
+    return synchronousSqliteUnavailable();
+  }
   async actorSqlExecuteBatch(ctx, statements) {
     const results = await callWasm(
       () => this.#actorSql(ctx).executeBatch(statements)
@@ -25806,27 +26127,42 @@ var WasmCoreRuntime = class {
       () => this.#actorSql(ctx).beginTransaction(timeoutMs, name)
     );
   }
+  actorSqlBeginTransactionSync(_ctx, _timeoutMs, _name) {
+    return synchronousSqliteUnavailable();
+  }
   async actorSqlTransactionExec(transaction, sql) {
     return await callWasm(
       () => transaction.exec(sql)
     );
   }
+  actorSqlTransactionExecSync(_transaction, _sql) {
+    return synchronousSqliteUnavailable();
+  }
   async actorSqlTransactionExecute(transaction, sql, params) {
     const result = await callWasm(
       () => transaction.execute(sql, params)
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorSqlTransactionExecuteSync(_transaction, _sql, _params) {
+    return synchronousSqliteUnavailable();
+  }
   async actorSqlTransactionCommit(transaction) {
     await callWasm(
       () => transaction.commit()
     );
   }
+  actorSqlTransactionCommitSync(_transaction) {
+    synchronousSqliteUnavailable();
+  }
   async actorSqlTransactionRollback(transaction) {
     await callWasm(
       () => transaction.rollback()
     );
   }
+  actorSqlTransactionRollbackSync(_transaction) {
+    synchronousSqliteUnavailable();
+  }
   async actorBeginStateTransaction(ctx, timeoutMs) {
     return await callWasm(
       () => asWasmActorContext(ctx).beginStateTransaction(timeoutMs)
@@ -25838,6 +26174,9 @@ var WasmCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  actorStateTransactionExecuteSync(_transaction, _sql, _params) {
+    return synchronousSqliteUnavailable();
+  }
   async actorStateTransactionCommit(transaction, payload) {
     await callWasm(
       () => transaction.commit(payload)
@@ -26326,7 +26665,7 @@ function getNativePersistState(runtime, ctx) {
   }
   return persistState;
 }
-function isPromiseLike2(value) {
+function isPromiseLike22(value) {
   return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function getNativeConnPersistState(runtime, ctx, conn) {
@@ -26472,6 +26811,18 @@ async function closeNativeDatabaseClient(runtime, ctx) {
     await entry.client.close();
   }
 }
+function createNativeSqlTransaction(runtime, transaction) {
+  return {
+    exec: (sql) => runtime.actorSqlTransactionExec(transaction, sql),
+    execSync: (sql) => runtime.actorSqlTransactionExecSync(transaction, sql),
+    execute: (sql, params) => runtime.actorSqlTransactionExecute(transaction, sql, params),
+    executeSync: (sql, params) => runtime.actorSqlTransactionExecuteSync(transaction, sql, params),
+    commit: () => runtime.actorSqlTransactionCommit(transaction),
+    commitSync: () => runtime.actorSqlTransactionCommitSync(transaction),
+    rollback: () => runtime.actorSqlTransactionRollback(transaction),
+    rollbackSync: () => runtime.actorSqlTransactionRollbackSync(transaction)
+  };
+}
 function getOrCreateNativeSqlDatabase(runtime, ctx) {
   const runtimeState = getNativeRuntimeState(runtime, ctx);
   const cachedDatabase = runtimeState.sql;
@@ -26480,7 +26831,9 @@ function getOrCreateNativeSqlDatabase(runtime, ctx) {
   }
   const database = wrapJsNativeDatabase({
     exec: (sql) => runtime.actorSqlExec(ctx, sql),
+    execSync: (sql) => runtime.actorSqlExecSync(ctx, sql),
     execute: (sql, params) => runtime.actorSqlExecute(ctx, sql, params),
+    executeSync: (sql, params) => runtime.actorSqlExecuteSync(ctx, sql, params),
     executeBatch: (statements) => runtime.actorSqlExecuteBatch(ctx, statements),
     beginTransaction: async (timeoutMs, name) => {
       const transaction = await runtime.actorSqlBeginTransaction(
@@ -26488,16 +26841,15 @@ function getOrCreateNativeSqlDatabase(runtime, ctx) {
         timeoutMs,
         name
       );
-      return {
-        exec: (sql) => runtime.actorSqlTransactionExec(transaction, sql),
-        execute: (sql, params) => runtime.actorSqlTransactionExecute(
-          transaction,
-          sql,
-          params
-        ),
-        commit: () => runtime.actorSqlTransactionCommit(transaction),
-        rollback: () => runtime.actorSqlTransactionRollback(transaction)
-      };
+      return createNativeSqlTransaction(runtime, transaction);
+    },
+    beginTransactionSync: (timeoutMs, name) => {
+      const transaction = runtime.actorSqlBeginTransactionSync(
+        ctx,
+        timeoutMs,
+        name
+      );
+      return createNativeSqlTransaction(runtime, transaction);
     },
     beginStateTransaction: async (timeoutMs, context) => {
       const scope = context;
@@ -26516,11 +26868,21 @@ function getOrCreateNativeSqlDatabase(runtime, ctx) {
             "actor state transactions only support single-statement execute calls"
           );
         },
+        execSync: () => {
+          throw new Error(
+            "actor state transactions only support single-statement execute calls"
+          );
+        },
         execute: (sql, params) => runtime.actorStateTransactionExecute(
           transaction,
           sql,
           params
         ),
+        executeSync: (sql, params) => runtime.actorStateTransactionExecuteSync(
+          transaction,
+          sql,
+          params
+        ),
         commit: async () => {
           await runtime.actorStateTransactionCommit(
             transaction,
@@ -28648,7 +29010,7 @@ var ActorContextHandleAdapter = class {
         this,
         actorState.state
       );
-      if (isPromiseLike2(result)) {
+      if (isPromiseLike22(result)) {
         shouldFinish = false;
         void Promise.resolve(result).catch((error46) => {
           logger22().error({