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

package/dist/tsup/agent-os/index.d.cts

@@ -79,9 +79,12 @@ interface SqliteNativeMetrics {
 }
 interface SqliteDatabase {
     exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
+    execSync?(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
     execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    executeSync?(sql: string, params?: SqliteBindings): SqliteExecuteResult;
     executeBatch(statements: SqliteBatchStatement[]): Promise<SqliteExecuteResult[]>;
     beginTransaction(timeoutMs?: number, name?: string): Promise<SqliteTransactionDatabase>;
+    beginTransactionSync?(timeoutMs?: number, name?: string): SynchronousSqliteTransactionDatabase;
     run(sql: string, params?: SqliteBindings): Promise<void>;
     query(sql: string, params?: SqliteBindings): Promise<SqliteQueryResult>;
     nativeMetrics?(): SqliteNativeMetrics | Promise<SqliteNativeMetrics | null> | null;
@@ -89,10 +92,18 @@ interface SqliteDatabase {
 }
 interface SqliteTransactionDatabase {
     exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
+    execSync?(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
     execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    executeSync?(sql: string, params?: SqliteBindings): SqliteExecuteResult;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }
+type SynchronousSqliteTransactionDatabase = SqliteTransactionDatabase & {
+    execSync(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
+    executeSync(sql: string, params?: SqliteBindings): SqliteExecuteResult;
+    commitSync(): void;
+    rollbackSync(): void;
+};
 /**
  * Provider for opening native databases from the active runtime.
  */
@@ -161,11 +172,21 @@ type DatabaseProvider<DB extends RawAccess> = {
  */
 type DrizzleDatabaseClient = {};
 type ExecuteFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]>;
+type ExecuteSyncFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => TRow[];
+/** SQL operations available inside a synchronous transaction callback. */
+type SynchronousTransactionAccess = {
+    executeSync: ExecuteSyncFunction;
+};
 type RawAccess = {
     /**
      * Executes a raw SQL query.
      */
     execute: ExecuteFunction;
+    /**
+     * Executes a raw SQL query synchronously when supported by the runtime.
+     * This blocks the Node.js event loop. Prefer `execute` for normal use.
+     */
+    executeSync?: ExecuteSyncFunction;
     /** Runs a callback in an isolated SQLite transaction. */
     transaction: <T>(callback: (tx: RawAccess) => Promise<T> | T, options?: SqliteTransactionOptions) => Promise<T>;
     /**
@@ -177,6 +198,15 @@ type RawAccess = {
      */
     close: () => Promise<void>;
 };
+/** Raw database access with synchronous operations provided by the Node.js runtime. */
+type SynchronousRawAccess = RawAccess & {
+    executeSync: ExecuteSyncFunction;
+    /**
+     * Runs a synchronous callback in an isolated SQLite transaction.
+     * The callback must not return a promise.
+     */
+    transactionSync: <T>(callback: (tx: SynchronousTransactionAccess) => T, options?: Omit<SqliteTransactionOptions, "experimental">) => T;
+};
 
 declare const ActorsSchema: z.ZodRecord<z.ZodString, z.ZodCustom<AnyActorDefinition, AnyActorDefinition>>;
 type RegistryActors = z.infer<typeof ActorsSchema>;
@@ -999,15 +1029,23 @@ interface CoreRuntime {
     actorKvBatchPut(ctx: ActorContextHandle, entries: RuntimeKvEntry[]): Promise<void>;
     actorKvBatchDelete(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<void>;
     actorSqlExec(ctx: ActorContextHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlExecSync(ctx: ActorContextHandle, sql: string): RuntimeSqlExecResult;
     actorSqlExecute(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlExecuteSync(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorSqlExecuteBatch(ctx: ActorContextHandle, statements: RuntimeSqlBatchStatement[]): Promise<RuntimeSqlExecuteResult[]>;
     actorSqlBeginTransaction(ctx: ActorContextHandle, timeoutMs?: number, name?: string): Promise<SqliteTransactionHandle>;
+    actorSqlBeginTransactionSync(ctx: ActorContextHandle, timeoutMs?: number, name?: string): SqliteTransactionHandle;
     actorSqlTransactionExec(transaction: SqliteTransactionHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlTransactionExecSync(transaction: SqliteTransactionHandle, sql: string): RuntimeSqlExecResult;
     actorSqlTransactionExecute(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlTransactionExecuteSync(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorSqlTransactionCommit(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionCommitSync(transaction: SqliteTransactionHandle): void;
     actorSqlTransactionRollback(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionRollbackSync(transaction: SqliteTransactionHandle): void;
     actorBeginStateTransaction(ctx: ActorContextHandle, timeoutMs?: number): Promise<ActorStateTransactionHandle>;
     actorStateTransactionExecute(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorStateTransactionExecuteSync(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorStateTransactionCommit(transaction: ActorStateTransactionHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
     actorStateTransactionRollback(transaction: ActorStateTransactionHandle): Promise<void>;
     actorSqlQuery(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlQueryResult>;
@@ -2421,7 +2459,7 @@ declare function buildFilesystemActions<TConnParams>(config: AgentOsActorConfig<
 declare function ensureVm<TConnParams>(c: AgentOsActionContext<TConnParams>, config: AgentOsActorConfig<TConnParams>): Promise<AgentOs>;
 declare function syncPreventSleep<TConnParams>(c: AgentOsActionContext<TConnParams>): void;
 declare function runHook<TConnParams>(c: AgentOsActionContext<TConnParams>, name: string, callback: () => void | Promise<void>): void;
-declare function agentOs<TConnParams = undefined>(config: AgentOsActorConfigInput<TConnParams>): ActorDefinition<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<RawAccess>, {
+declare function agentOs<TConnParams = undefined>(config: AgentOsActorConfigInput<TConnParams>): ActorDefinition<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<SynchronousRawAccess>, {
     sessionEvent: typeof sessionEventToken;
     permissionRequest: typeof permissionRequestToken;
     vmBooted: typeof vmBootedToken;
@@ -2456,7 +2494,7 @@ declare function buildNetworkActions<TConnParams>(config: AgentOsActorConfig<TCo
 };
 
 declare function generateToken(): string;
-type AgentOsRequestContext<TConnParams> = RequestContext<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<RawAccess>>;
+type AgentOsRequestContext<TConnParams> = RequestContext<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<SynchronousRawAccess>>;
 declare function buildOnRequestHandler<TConnParams>(config: AgentOsActorConfig<TConnParams>): (c: AgentOsRequestContext<TConnParams>, request: Request) => Promise<Response>;
 declare function buildPreviewActions<TConnParams>(config: AgentOsActorConfig<TConnParams>): {
     createSignedPreviewUrl: (c: AgentOsActionContext<TConnParams>, port: number, expiresInSeconds?: number) => Promise<{

package/dist/tsup/agent-os/index.d.ts

@@ -79,9 +79,12 @@ interface SqliteNativeMetrics {
 }
 interface SqliteDatabase {
     exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
+    execSync?(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
     execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    executeSync?(sql: string, params?: SqliteBindings): SqliteExecuteResult;
     executeBatch(statements: SqliteBatchStatement[]): Promise<SqliteExecuteResult[]>;
     beginTransaction(timeoutMs?: number, name?: string): Promise<SqliteTransactionDatabase>;
+    beginTransactionSync?(timeoutMs?: number, name?: string): SynchronousSqliteTransactionDatabase;
     run(sql: string, params?: SqliteBindings): Promise<void>;
     query(sql: string, params?: SqliteBindings): Promise<SqliteQueryResult>;
     nativeMetrics?(): SqliteNativeMetrics | Promise<SqliteNativeMetrics | null> | null;
@@ -89,10 +92,18 @@ interface SqliteDatabase {
 }
 interface SqliteTransactionDatabase {
     exec(sql: string, callback?: (row: unknown[], columns: string[]) => void): Promise<void>;
+    execSync?(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
     execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
+    executeSync?(sql: string, params?: SqliteBindings): SqliteExecuteResult;
     commit(): Promise<void>;
     rollback(): Promise<void>;
 }
+type SynchronousSqliteTransactionDatabase = SqliteTransactionDatabase & {
+    execSync(sql: string, callback?: (row: unknown[], columns: string[]) => void): void;
+    executeSync(sql: string, params?: SqliteBindings): SqliteExecuteResult;
+    commitSync(): void;
+    rollbackSync(): void;
+};
 /**
  * Provider for opening native databases from the active runtime.
  */
@@ -161,11 +172,21 @@ type DatabaseProvider<DB extends RawAccess> = {
  */
 type DrizzleDatabaseClient = {};
 type ExecuteFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]>;
+type ExecuteSyncFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => TRow[];
+/** SQL operations available inside a synchronous transaction callback. */
+type SynchronousTransactionAccess = {
+    executeSync: ExecuteSyncFunction;
+};
 type RawAccess = {
     /**
      * Executes a raw SQL query.
      */
     execute: ExecuteFunction;
+    /**
+     * Executes a raw SQL query synchronously when supported by the runtime.
+     * This blocks the Node.js event loop. Prefer `execute` for normal use.
+     */
+    executeSync?: ExecuteSyncFunction;
     /** Runs a callback in an isolated SQLite transaction. */
     transaction: <T>(callback: (tx: RawAccess) => Promise<T> | T, options?: SqliteTransactionOptions) => Promise<T>;
     /**
@@ -177,6 +198,15 @@ type RawAccess = {
      */
     close: () => Promise<void>;
 };
+/** Raw database access with synchronous operations provided by the Node.js runtime. */
+type SynchronousRawAccess = RawAccess & {
+    executeSync: ExecuteSyncFunction;
+    /**
+     * Runs a synchronous callback in an isolated SQLite transaction.
+     * The callback must not return a promise.
+     */
+    transactionSync: <T>(callback: (tx: SynchronousTransactionAccess) => T, options?: Omit<SqliteTransactionOptions, "experimental">) => T;
+};
 
 declare const ActorsSchema: z.ZodRecord<z.ZodString, z.ZodCustom<AnyActorDefinition, AnyActorDefinition>>;
 type RegistryActors = z.infer<typeof ActorsSchema>;
@@ -999,15 +1029,23 @@ interface CoreRuntime {
     actorKvBatchPut(ctx: ActorContextHandle, entries: RuntimeKvEntry[]): Promise<void>;
     actorKvBatchDelete(ctx: ActorContextHandle, keys: RuntimeBytes[]): Promise<void>;
     actorSqlExec(ctx: ActorContextHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlExecSync(ctx: ActorContextHandle, sql: string): RuntimeSqlExecResult;
     actorSqlExecute(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlExecuteSync(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorSqlExecuteBatch(ctx: ActorContextHandle, statements: RuntimeSqlBatchStatement[]): Promise<RuntimeSqlExecuteResult[]>;
     actorSqlBeginTransaction(ctx: ActorContextHandle, timeoutMs?: number, name?: string): Promise<SqliteTransactionHandle>;
+    actorSqlBeginTransactionSync(ctx: ActorContextHandle, timeoutMs?: number, name?: string): SqliteTransactionHandle;
     actorSqlTransactionExec(transaction: SqliteTransactionHandle, sql: string): Promise<RuntimeSqlExecResult>;
+    actorSqlTransactionExecSync(transaction: SqliteTransactionHandle, sql: string): RuntimeSqlExecResult;
     actorSqlTransactionExecute(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorSqlTransactionExecuteSync(transaction: SqliteTransactionHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorSqlTransactionCommit(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionCommitSync(transaction: SqliteTransactionHandle): void;
     actorSqlTransactionRollback(transaction: SqliteTransactionHandle): Promise<void>;
+    actorSqlTransactionRollbackSync(transaction: SqliteTransactionHandle): void;
     actorBeginStateTransaction(ctx: ActorContextHandle, timeoutMs?: number): Promise<ActorStateTransactionHandle>;
     actorStateTransactionExecute(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlExecuteResult>;
+    actorStateTransactionExecuteSync(transaction: ActorStateTransactionHandle, sql: string, params?: RuntimeSqlBindParams): RuntimeSqlExecuteResult;
     actorStateTransactionCommit(transaction: ActorStateTransactionHandle, payload: RuntimeStateDeltaPayload): Promise<void>;
     actorStateTransactionRollback(transaction: ActorStateTransactionHandle): Promise<void>;
     actorSqlQuery(ctx: ActorContextHandle, sql: string, params?: RuntimeSqlBindParams): Promise<RuntimeSqlQueryResult>;
@@ -2421,7 +2459,7 @@ declare function buildFilesystemActions<TConnParams>(config: AgentOsActorConfig<
 declare function ensureVm<TConnParams>(c: AgentOsActionContext<TConnParams>, config: AgentOsActorConfig<TConnParams>): Promise<AgentOs>;
 declare function syncPreventSleep<TConnParams>(c: AgentOsActionContext<TConnParams>): void;
 declare function runHook<TConnParams>(c: AgentOsActionContext<TConnParams>, name: string, callback: () => void | Promise<void>): void;
-declare function agentOs<TConnParams = undefined>(config: AgentOsActorConfigInput<TConnParams>): ActorDefinition<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<RawAccess>, {
+declare function agentOs<TConnParams = undefined>(config: AgentOsActorConfigInput<TConnParams>): ActorDefinition<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<SynchronousRawAccess>, {
     sessionEvent: typeof sessionEventToken;
     permissionRequest: typeof permissionRequestToken;
     vmBooted: typeof vmBootedToken;
@@ -2456,7 +2494,7 @@ declare function buildNetworkActions<TConnParams>(config: AgentOsActorConfig<TCo
 };
 
 declare function generateToken(): string;
-type AgentOsRequestContext<TConnParams> = RequestContext<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<RawAccess>>;
+type AgentOsRequestContext<TConnParams> = RequestContext<AgentOsActorState, TConnParams, undefined, AgentOsActorVars, undefined, DatabaseProvider<SynchronousRawAccess>>;
 declare function buildOnRequestHandler<TConnParams>(config: AgentOsActorConfig<TConnParams>): (c: AgentOsRequestContext<TConnParams>, request: Request) => Promise<Response>;
 declare function buildPreviewActions<TConnParams>(config: AgentOsActorConfig<TConnParams>): {
     createSignedPreviewUrl: (c: AgentOsActionContext<TConnParams>, port: number, expiresInSeconds?: number) => Promise<{

package/dist/tsup/agent-os/index.js

@@ -420,7 +420,7 @@ function isRivetErrorCode(error, group, code) {
 // package.json
 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: [
@@ -921,6 +921,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 (error) {
+    try {
+      transaction.rollbackSync();
+    } catch {
+    }
+    throw error;
+  }
+}
 function isSqliteBindingValue(value) {
   if (value === null || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || value instanceof Uint8Array) {
     return true;
@@ -983,6 +1015,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(
@@ -990,16 +1023,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 _a, _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 = ((_a = ctx.metrics) == null ? void 0 : _a.totalKvReads) ?? 0;
@@ -1045,8 +1086,66 @@ function db({
               }
             }
           },
+          executeSync: (query, ...args) => {
+            var _a, _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 = ((_a = ctx.metrics) == null ? void 0 : _a.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 _a, _b;
+            ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
             validateTransactionTimeout(options == null ? void 0 : options.timeout);
             validateTransactionName(options == null ? void 0 : options.name);
             if (transactionScoped && ((_a = options == null ? void 0 : options.experimental) == null ? void 0 : _a.includeState)) {
@@ -1092,6 +1191,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;
@@ -1143,6 +1269,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) => {