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

package/dist/browser/client.d.ts

@@ -77,9 +77,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;
@@ -87,10 +90,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.
  */
@@ -159,11 +170,17 @@ 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[];
 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>;
     /**
@@ -2215,15 +2232,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>;

package/dist/browser/client.js

@@ -201,7 +201,7 @@ function noopNext() {
 // 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.527e186",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -5921,6 +5921,15 @@ var AsyncMutex = class {
 };
 
 // src/client/raw-utils.ts
+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 path;
   let originalUrl;
@@ -6459,9 +6468,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,
@@ -6481,7 +6491,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
         );