@tanstack/ai-client 0.22.0 → 0.23.0

package/dist/esm/video-generation-client.js

@@ -1,382 +1,668 @@
-import { GENERATION_EVENTS } from "./generation-types.js";
 import { createNoOpVideoDevtoolsBridge } from "./devtools-noop.js";
+import { GENERATION_EVENTS, GENERATION_STREAM_TRUNCATED_MESSAGE, GENERATION_UNRESTORABLE_RESULT_MESSAGE, clientStateFromResumeStatus, createGenerationHydrationError, createGenerationResultSnapshot, parseGenerationResumeSnapshot, updateGenerationResumeSnapshot } from "./generation-types.js";
 import { parseSSEResponse } from "./sse-parser.js";
-class VideoGenerationClient {
-  connection;
-  fetcher;
-  uniqueId;
-  devtoolsMetadata;
-  devtoolsBridge;
-  threadId;
-  body;
-  result = null;
-  input = null;
-  progress = null;
-  jobId = null;
-  videoStatus = null;
-  isLoading = false;
-  error = void 0;
-  status = "idle";
-  abortController = null;
-  callbacksRef;
-  devtoolsMounted = false;
-  constructor(options) {
-    this.uniqueId = options.id ?? this.generateUniqueId("video");
-    this.threadId = this.uniqueId;
-    this.connection = options.connection;
-    this.fetcher = options.fetcher;
-    this.body = options.body ?? {};
-    this.callbacksRef = {
-      onResult: options.onResult,
-      onError: options.onError,
-      onProgress: options.onProgress,
-      onChunk: options.onChunk,
-      onJobCreated: options.onJobCreated,
-      onStatusUpdate: options.onStatusUpdate,
-      onResultChange: options.onResultChange,
-      onLoadingChange: options.onLoadingChange,
-      onErrorChange: options.onErrorChange,
-      onStatusChange: options.onStatusChange,
-      onJobIdChange: options.onJobIdChange,
-      onVideoStatusChange: options.onVideoStatusChange
-    };
-    this.devtoolsMetadata = this.createDevtoolsMetadata(options.devtools);
-    this.devtoolsBridge = (options.devtoolsBridgeFactory ?? createNoOpVideoDevtoolsBridge)(this.buildDevtoolsBridgeOptions());
-  }
-  buildDevtoolsBridgeOptions() {
-    return {
-      hookId: this.uniqueId,
-      clientId: this.uniqueId,
-      threadId: this.threadId,
-      metadata: this.devtoolsMetadata,
-      getCoreState: () => ({
-        input: this.input,
-        result: this.result,
-        progress: this.progress,
-        status: this.status,
-        isLoading: this.isLoading,
-        jobId: this.jobId,
-        videoStatus: this.videoStatus,
-        ...this.error ? { error: this.error.message } : {}
-      })
-    };
-  }
-  mountDevtools() {
-    if (this.devtoolsMounted) {
-      return;
-    }
-    this.devtoolsMounted = true;
-    this.devtoolsBridge.emitRegistered();
-    this.devtoolsBridge.emitSnapshot();
-  }
-  /**
-   * Trigger video generation.
-   * Only one generation can be in-flight at a time.
-   */
-  async generate(input) {
-    this.mountDevtools();
-    if (this.isLoading) return;
-    this.input = input;
-    this.progress = null;
-    const runId = this.devtoolsBridge.beginRun(input);
-    this.setIsLoading(true);
-    this.setStatus("generating");
-    this.setError(void 0);
-    this.setJobId(null);
-    this.setVideoStatus(null);
-    const abortController = new AbortController();
-    this.abortController = abortController;
-    const { signal } = abortController;
-    try {
-      if (this.fetcher) {
-        await this.generateWithFetcher(input, signal, runId);
-      } else if (this.connection) {
-        const mergedData = { ...this.body, ...input };
-        const stream = this.connection.connect(
-          [],
-          mergedData,
-          signal,
-          this.createRunContext(runId)
-        );
-        await this.processStream(stream, runId);
-      } else {
-        throw new Error(
-          "VideoGenerationClient requires either a connection or fetcher option"
-        );
-      }
-      if (!signal.aborted && this.status === "success") {
-        this.devtoolsBridge.finishRun(
-          this.devtoolsBridge.getActiveRunId() ?? runId,
-          "run:completed",
-          "completed"
-        );
-      }
-    } catch (err) {
-      if (signal.aborted) return;
-      const error = err instanceof Error ? err : new Error(String(err));
-      this.setError(error);
-      this.setStatus("error");
-      this.devtoolsBridge.finishRun(
-        this.devtoolsBridge.getActiveRunId() ?? runId,
-        "run:errored",
-        "errored",
-        error.message
-      );
-      this.callbacksRef.onError?.(error);
-    } finally {
-      this.abortController = null;
-      this.setIsLoading(false);
-    }
-  }
-  /**
-   * Direct fetcher mode: call fetcher and set result.
-   */
-  async generateWithFetcher(input, signal, runId) {
-    if (!this.fetcher) return;
-    const result = await this.fetcher(input, { signal });
-    if (signal.aborted) return;
-    if (result instanceof Response) {
-      await this.processStream(parseSSEResponse(result, signal), runId);
-    } else {
-      this.devtoolsBridge.ensureRunStarted(runId);
-      this.setResult(result);
-      this.setStatus("success");
-    }
-  }
-  /**
-   * Process a stream of AG-UI events from the streaming connection adapter.
-   * The server handles the polling loop and streams status updates.
-   */
-  async processStream(source, fallbackRunId) {
-    let streamRunId;
-    for await (const chunk of source) {
-      if (this.abortController?.signal.aborted) break;
-      this.callbacksRef.onChunk?.(chunk);
-      const chunkRunId = "runId" in chunk && typeof chunk.runId === "string" ? chunk.runId : void 0;
-      switch (chunk.type) {
-        case "RUN_STARTED": {
-          streamRunId = chunk.runId;
-          this.devtoolsBridge.ensureRunStarted(chunk.runId);
-          break;
-        }
-        case "CUSTOM": {
-          this.devtoolsBridge.ensureRunStarted(streamRunId ?? fallbackRunId);
-          if (chunk.name === GENERATION_EVENTS.VIDEO_JOB_CREATED) {
-            const { jobId } = chunk.value;
-            this.setJobId(jobId);
-            this.callbacksRef.onJobCreated?.(jobId);
-          } else if (chunk.name === GENERATION_EVENTS.VIDEO_STATUS) {
-            const statusInfo = chunk.value;
-            this.setVideoStatus(statusInfo);
-            this.callbacksRef.onStatusUpdate?.(statusInfo);
-            if (statusInfo.progress !== void 0) {
-              this.setProgress(statusInfo.progress);
-            }
-          } else if (chunk.name === GENERATION_EVENTS.RESULT) {
-            this.setResult(chunk.value);
-          } else if (chunk.name === GENERATION_EVENTS.PROGRESS) {
-            const { progress, message } = chunk.value;
-            this.setProgress(progress, message);
-          }
-          break;
-        }
-        case "RUN_FINISHED": {
-          streamRunId = chunk.runId;
-          this.devtoolsBridge.ensureRunStarted(chunk.runId);
-          this.setStatus("success");
-          break;
-        }
-        case "RUN_ERROR": {
-          this.devtoolsBridge.ensureRunStarted(
-            chunkRunId ?? streamRunId ?? fallbackRunId
-          );
-          const msg = chunk.message || chunk.error?.message || "An error occurred";
-          throw new Error(msg);
-        }
-      }
-    }
-  }
-  /**
-   * Abort any in-flight generation or polling.
-   */
-  stop() {
-    const runId = this.devtoolsBridge.getActiveRunId();
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = null;
-    }
-    this.setIsLoading(false);
-    if (this.status === "generating") {
-      this.setStatus("idle");
-      if (runId) {
-        this.devtoolsBridge.finishRun(runId, "run:cancelled", "cancelled");
-      }
-    }
-  }
-  /**
-   * Clear all state and return to idle.
-   */
-  reset() {
-    this.stop();
-    this.setResult(null);
-    this.input = null;
-    this.progress = null;
-    this.devtoolsBridge.resetRuns();
-    this.setJobId(null);
-    this.setVideoStatus(null);
-    this.setError(void 0);
-    this.setStatus("idle");
-    this.devtoolsBridge.emitState();
-  }
-  /**
-   * Update options without recreating the client.
-   */
-  updateOptions(options) {
-    if (options.body !== void 0) {
-      this.body = options.body ?? {};
-    }
-    if (options.onResult !== void 0) {
-      this.callbacksRef.onResult = options.onResult;
-    }
-    if (options.onError !== void 0) {
-      this.callbacksRef.onError = options.onError;
-    }
-    if (options.onProgress !== void 0) {
-      this.callbacksRef.onProgress = options.onProgress;
-    }
-    if (options.onChunk !== void 0) {
-      this.callbacksRef.onChunk = options.onChunk;
-    }
-    if (options.onJobCreated !== void 0) {
-      this.callbacksRef.onJobCreated = options.onJobCreated;
-    }
-    if (options.onStatusUpdate !== void 0) {
-      this.callbacksRef.onStatusUpdate = options.onStatusUpdate;
-    }
-  }
-  dispose() {
-    this.stop();
-    this.devtoolsBridge.dispose();
-    this.devtoolsMounted = false;
-  }
-  // ===========================
-  // Getters
-  // ===========================
-  getResult() {
-    return this.result;
-  }
-  getJobId() {
-    return this.jobId;
-  }
-  getVideoStatus() {
-    return this.videoStatus;
-  }
-  getIsLoading() {
-    return this.isLoading;
-  }
-  getError() {
-    return this.error;
-  }
-  getStatus() {
-    return this.status;
-  }
-  // ===========================
-  // Private state setters
-  // ===========================
-  setResult(rawResult) {
-    if (rawResult === null) {
-      this.result = null;
-      this.callbacksRef.onResultChange?.(null);
-      this.devtoolsBridge.recordResultChange();
-      return;
-    }
-    const completedStatus = this.createCompletedVideoStatus(rawResult);
-    if (this.progress?.value !== 100) {
-      this.setProgress(100, this.progress?.message);
-    }
-    this.setJobId(rawResult.jobId);
-    this.setVideoStatus(completedStatus);
-    if (this.callbacksRef.onResult) {
-      const transformed = this.callbacksRef.onResult(rawResult);
-      if (transformed === null) {
-        this.devtoolsBridge.emitState();
-        return;
-      }
-      if (transformed !== void 0) {
-        this.result = transformed;
-        this.callbacksRef.onResultChange?.(this.result);
-        this.devtoolsBridge.recordResultChange();
-        return;
-      }
-    }
-    this.result = rawResult;
-    this.callbacksRef.onResultChange?.(this.result);
-    this.devtoolsBridge.recordResultChange();
-  }
-  setJobId(jobId) {
-    this.jobId = jobId;
-    this.callbacksRef.onJobIdChange?.(jobId);
-    this.devtoolsBridge.recordJobIdChange();
-  }
-  setVideoStatus(status) {
-    this.videoStatus = status;
-    this.callbacksRef.onVideoStatusChange?.(status);
-    this.devtoolsBridge.recordVideoStatusChange();
-  }
-  setIsLoading(isLoading) {
-    this.isLoading = isLoading;
-    this.callbacksRef.onLoadingChange?.(isLoading);
-    this.devtoolsBridge.recordLoadingChange();
-  }
-  setError(error) {
-    this.error = error;
-    this.callbacksRef.onErrorChange?.(error);
-    this.devtoolsBridge.recordErrorChange(error);
-  }
-  setStatus(status) {
-    this.status = status;
-    this.callbacksRef.onStatusChange?.(status);
-    this.devtoolsBridge.recordStatusChange(status);
-  }
-  setProgress(value, message) {
-    this.progress = {
-      value,
-      ...message ? { message } : {}
-    };
-    if (message === void 0) {
-      this.callbacksRef.onProgress?.(value);
-    } else {
-      this.callbacksRef.onProgress?.(value, message);
-    }
-    this.devtoolsBridge.recordProgressChange();
-  }
-  createCompletedVideoStatus(result) {
-    return {
-      jobId: result.jobId,
-      status: result.status,
-      progress: 100,
-      url: result.url
-    };
-  }
-  createDevtoolsMetadata(metadata) {
-    return {
-      hookName: metadata?.hookName ?? "useGenerateVideo",
-      outputKind: metadata?.outputKind ?? "video",
-      ...metadata?.framework ? { framework: metadata.framework } : {},
-      ...metadata?.name ? { name: metadata.name } : {}
-    };
-  }
-  generateUniqueId(prefix) {
-    return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-  }
-  createRunContext(runId) {
-    return {
-      threadId: this.threadId,
-      runId
-    };
-  }
-}
-export {
-  VideoGenerationClient
+//#region src/video-generation-client.ts
+/**
+* A specialized client for job-based video generation.
+*
+* Video generation is asynchronous: a job is created, then polled for status
+* until completion. This client handles the full lifecycle.
+*
+* Supports two transport modes:
+* - **ConnectConnectionAdapter** — Server handles the polling loop internally and
+*   streams status updates via CUSTOM events.
+* - **Fetcher** — Direct async function that returns a completed
+*   `VideoGenerateResult`.
+*
+* @example
+* ```typescript
+* // With streaming connection adapter (server-driven polling)
+* const client = new VideoGenerationClient({
+*   connection: fetchServerSentEvents('/api/generate/video'),
+*   onResultChange: setResult,
+*   onVideoStatusChange: setVideoStatus,
+* })
+*
+* // With fetcher (direct result)
+* const client = new VideoGenerationClient({
+*   fetcher: async (input) => {
+*     const res = await fetch('/api/video/generate', {
+*       method: 'POST',
+*       body: JSON.stringify(input),
+*     })
+*     return res.json() // { jobId, status: 'completed', url, expiresAt }
+*   },
+* })
+*
+* await client.generate({ prompt: 'A flying car over a city' })
+* ```
+*/
+var VideoGenerationClient = class {
+	connection;
+	hydrateGenerationHandler;
+	joinRunHandler;
+	fetcher;
+	uniqueId;
+	devtoolsMetadata;
+	devtoolsBridge;
+	threadId;
+	serverDriven = false;
+	body;
+	result = null;
+	input = null;
+	progress = null;
+	jobId = null;
+	videoStatus = null;
+	isLoading = false;
+	error = void 0;
+	status = "idle";
+	resumeSnapshot;
+	abortController = null;
+	rejoinedRunId;
+	callbacksRef;
+	devtoolsMounted = false;
+	disposed = false;
+	serverHydrationStarted = false;
+	constructor(options) {
+		this.uniqueId = options.threadId ?? options.id ?? this.generateUniqueId("video");
+		this.threadId = options.threadId ?? this.uniqueId;
+		this.connection = options.connection;
+		this.fetcher = options.fetcher;
+		this.hydrateGenerationHandler = options.hydrateGeneration;
+		this.joinRunHandler = options.joinRun;
+		this.body = options.body ?? {};
+		this.serverDriven = options.persistence === true;
+		this.callbacksRef = {
+			onResult: options.onResult,
+			onError: options.onError,
+			onProgress: options.onProgress,
+			onChunk: options.onChunk,
+			onJobCreated: options.onJobCreated,
+			onStatusUpdate: options.onStatusUpdate,
+			onResultChange: options.onResultChange,
+			onLoadingChange: options.onLoadingChange,
+			onErrorChange: options.onErrorChange,
+			onStatusChange: options.onStatusChange,
+			onJobIdChange: options.onJobIdChange,
+			onVideoStatusChange: options.onVideoStatusChange,
+			onResumeSnapshotChange: options.onResumeSnapshotChange,
+			onResumeStateChange: options.onResumeStateChange
+		};
+		this.devtoolsMetadata = this.createDevtoolsMetadata(options.devtools);
+		this.devtoolsBridge = (options.devtoolsBridgeFactory ?? createNoOpVideoDevtoolsBridge)(this.buildDevtoolsBridgeOptions());
+	}
+	buildDevtoolsBridgeOptions() {
+		return {
+			hookId: this.uniqueId,
+			clientId: this.uniqueId,
+			threadId: this.threadId,
+			metadata: this.devtoolsMetadata,
+			getCoreState: () => ({
+				input: this.input,
+				result: this.result,
+				progress: this.progress,
+				status: this.status,
+				isLoading: this.isLoading,
+				jobId: this.jobId,
+				videoStatus: this.videoStatus,
+				...this.error ? { error: this.error.message } : {}
+			})
+		};
+	}
+	mountDevtools() {
+		this.disposed = false;
+		this.maybeHydrateFromServer();
+		this.maybeResumeInFlight();
+		if (this.devtoolsMounted) return;
+		this.devtoolsMounted = true;
+		this.devtoolsBridge.emitRegistered();
+		this.devtoolsBridge.emitSnapshot();
+	}
+	/**
+	* Trigger video generation.
+	* Only one generation can be in-flight at a time.
+	*/
+	async generate(input) {
+		if (this.disposed) return;
+		if (this.isLoading) return;
+		this.mountDevtools();
+		this.input = input;
+		this.progress = null;
+		const runId = this.devtoolsBridge.beginRun(input);
+		this.setIsLoading(true);
+		this.setStatus("generating");
+		this.setError(void 0);
+		this.setJobId(null);
+		this.setVideoStatus(null);
+		const abortController = new AbortController();
+		this.abortController = abortController;
+		const { signal } = abortController;
+		try {
+			if (this.fetcher) await this.generateWithFetcher(input, signal, runId);
+			else if (this.connection) {
+				const mergedData = {
+					...this.body,
+					...input
+				};
+				const stream = this.connection.connect([], mergedData, signal, this.createRunContext(runId));
+				await this.processStream(stream, runId, signal);
+			} else throw new Error("VideoGenerationClient requires either a connection or fetcher option");
+			if (!signal.aborted && this.status === "success") this.devtoolsBridge.finishRun(this.devtoolsBridge.getActiveRunId() ?? runId, "run:completed", "completed");
+		} catch (err) {
+			if (signal.aborted) return;
+			const error = err instanceof Error ? err : new Error(String(err));
+			this.setError(error);
+			this.setStatus("error");
+			this.recordResumeSnapshotError(error);
+			this.devtoolsBridge.finishRun(this.devtoolsBridge.getActiveRunId() ?? runId, "run:errored", "errored", error.message);
+			this.callbacksRef.onError?.(error);
+		} finally {
+			if (this.abortController === abortController) {
+				this.abortController = null;
+				this.setIsLoading(false);
+			}
+		}
+	}
+	/**
+	* Direct fetcher mode: call fetcher and set result.
+	*/
+	async generateWithFetcher(input, signal, runId) {
+		if (!this.fetcher) return;
+		const result = await this.fetcher(input, { signal });
+		if (signal.aborted) return;
+		if (result instanceof Response) await this.processStream(parseSSEResponse(result, signal), runId, signal);
+		else {
+			this.devtoolsBridge.ensureRunStarted(runId);
+			this.setResult(result);
+			this.setStatus("success");
+			this.completePlainFetcherResumeSnapshot(result);
+		}
+	}
+	/**
+	* Process a stream of AG-UI events from the streaming connection adapter.
+	* The server handles the polling loop and streams status updates.
+	*
+	* Throws {@link GENERATION_STREAM_TRUNCATED_MESSAGE} when the iteration ends
+	* without a terminal chunk — see the note on
+	* `GenerationClient.processStream`. Video runs are long enough that a proxy
+	* idle timeout mid-poll is the likeliest way to hit it.
+	*/
+	async processStream(source, fallbackRunId, signal) {
+		let streamRunId;
+		let sawTerminalChunk = false;
+		for await (const chunk of source) {
+			if (signal.aborted) break;
+			this.callbacksRef.onChunk?.(chunk);
+			this.observeResumeSnapshot(chunk);
+			const chunkRunId = "runId" in chunk && typeof chunk.runId === "string" ? chunk.runId : void 0;
+			switch (chunk.type) {
+				case "RUN_STARTED":
+					streamRunId = chunk.runId;
+					this.devtoolsBridge.ensureRunStarted(chunk.runId);
+					break;
+				case "CUSTOM":
+					this.devtoolsBridge.ensureRunStarted(streamRunId ?? fallbackRunId);
+					if (chunk.name === GENERATION_EVENTS.VIDEO_JOB_CREATED) {
+						const { jobId } = chunk.value;
+						this.setJobId(jobId);
+						this.callbacksRef.onJobCreated?.(jobId);
+					} else if (chunk.name === GENERATION_EVENTS.VIDEO_STATUS) {
+						const statusInfo = chunk.value;
+						this.setVideoStatus(statusInfo);
+						this.callbacksRef.onStatusUpdate?.(statusInfo);
+						if (statusInfo.progress !== void 0) this.setProgress(statusInfo.progress);
+					} else if (chunk.name === GENERATION_EVENTS.RESULT) this.setResult(chunk.value);
+					else if (chunk.name === GENERATION_EVENTS.PROGRESS) {
+						const { progress, message } = chunk.value;
+						this.setProgress(progress, message);
+					}
+					break;
+				case "RUN_FINISHED":
+					streamRunId = chunk.runId;
+					sawTerminalChunk = true;
+					this.devtoolsBridge.ensureRunStarted(chunk.runId);
+					this.setStatus("success");
+					break;
+				case "RUN_ERROR": {
+					this.devtoolsBridge.ensureRunStarted(chunkRunId ?? streamRunId ?? fallbackRunId);
+					const msg = chunk.message || chunk.error?.message || "An error occurred";
+					throw new Error(msg);
+				}
+				default: break;
+			}
+		}
+		if (!sawTerminalChunk && !signal.aborted) throw new Error(GENERATION_STREAM_TRUNCATED_MESSAGE);
+	}
+	/**
+	* Abort any in-flight generation or polling.
+	*/
+	stop() {
+		const runId = this.devtoolsBridge.getActiveRunId();
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		this.setIsLoading(false);
+		if (this.status === "generating") {
+			this.setStatus("idle");
+			if (runId) this.devtoolsBridge.finishRun(runId, "run:cancelled", "cancelled");
+		}
+		if (this.resumeSnapshot && this.resumeSnapshot.status === "running") {
+			this.resumeSnapshot = {
+				...this.resumeSnapshot,
+				resumeState: null,
+				status: "idle"
+			};
+			this.notifyResumeSnapshotChanged();
+		}
+	}
+	/**
+	* Clear all state and return to idle. Also drops the client's in-memory
+	* resume snapshot, so a remount restores nothing. The server-side record is
+	* untouched — this client no longer writes one — so a full page reload under
+	* `persistence: true` re-hydrates the last generation again.
+	*/
+	reset() {
+		this.stop();
+		this.setResult(null);
+		this.input = null;
+		this.progress = null;
+		this.devtoolsBridge.resetRuns();
+		this.setJobId(null);
+		this.setVideoStatus(null);
+		this.setError(void 0);
+		this.setStatus("idle");
+		this.clearResumeSnapshot();
+		this.devtoolsBridge.emitState();
+	}
+	/**
+	* Update options without recreating the client.
+	*/
+	updateOptions(options) {
+		if (options.body !== void 0) this.body = options.body ?? {};
+		if (options.onResult !== void 0) this.callbacksRef.onResult = options.onResult;
+		if (options.onError !== void 0) this.callbacksRef.onError = options.onError;
+		if (options.onProgress !== void 0) this.callbacksRef.onProgress = options.onProgress;
+		if (options.onChunk !== void 0) this.callbacksRef.onChunk = options.onChunk;
+		if (options.onJobCreated !== void 0) this.callbacksRef.onJobCreated = options.onJobCreated;
+		if (options.onStatusUpdate !== void 0) this.callbacksRef.onStatusUpdate = options.onStatusUpdate;
+	}
+	dispose() {
+		this.disposed = true;
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		this.setIsLoading(false);
+		this.devtoolsBridge.dispose();
+		this.devtoolsMounted = false;
+		this.serverHydrationStarted = false;
+		this.rejoinedRunId = void 0;
+	}
+	getResult() {
+		return this.result;
+	}
+	getJobId() {
+		return this.jobId;
+	}
+	getVideoStatus() {
+		return this.videoStatus;
+	}
+	getIsLoading() {
+		return this.isLoading;
+	}
+	getError() {
+		return this.error;
+	}
+	getStatus() {
+		return this.status;
+	}
+	getResumeSnapshot() {
+		return this.resumeSnapshot ? {
+			...this.resumeSnapshot,
+			...this.resumeSnapshot.pendingArtifacts ? { pendingArtifacts: [...this.resumeSnapshot.pendingArtifacts] } : {},
+			...this.resumeSnapshot.result ? { result: {
+				...this.resumeSnapshot.result,
+				...this.resumeSnapshot.result.artifacts ? { artifacts: [...this.resumeSnapshot.result.artifacts] } : {}
+			} } : {},
+			...this.resumeSnapshot.error ? { error: { ...this.resumeSnapshot.error } } : {},
+			...this.resumeSnapshot.lastEvent ? { lastEvent: { ...this.resumeSnapshot.lastEvent } } : {}
+		} : void 0;
+	}
+	setResult(rawResult) {
+		if (rawResult === null) {
+			this.result = null;
+			this.callbacksRef.onResultChange?.(null);
+			this.devtoolsBridge.recordResultChange();
+			return;
+		}
+		const completedStatus = this.createCompletedVideoStatus(rawResult);
+		if (this.progress?.value !== 100) this.setProgress(100, this.progress?.message);
+		this.setJobId(rawResult.jobId);
+		this.setVideoStatus(completedStatus);
+		if (this.callbacksRef.onResult) {
+			const transformed = this.callbacksRef.onResult(rawResult);
+			if (transformed === null) {
+				this.devtoolsBridge.emitState();
+				return;
+			}
+			if (transformed !== void 0) {
+				this.result = transformed;
+				this.callbacksRef.onResultChange?.(this.result);
+				this.devtoolsBridge.recordResultChange();
+				return;
+			}
+		}
+		this.result = rawResult;
+		this.callbacksRef.onResultChange?.(this.result);
+		this.devtoolsBridge.recordResultChange();
+	}
+	setJobId(jobId) {
+		this.jobId = jobId;
+		this.callbacksRef.onJobIdChange?.(jobId);
+		this.devtoolsBridge.recordJobIdChange();
+	}
+	setVideoStatus(status) {
+		this.videoStatus = status;
+		this.callbacksRef.onVideoStatusChange?.(status);
+		this.devtoolsBridge.recordVideoStatusChange();
+	}
+	setIsLoading(isLoading) {
+		this.isLoading = isLoading;
+		this.callbacksRef.onLoadingChange?.(isLoading);
+		this.devtoolsBridge.recordLoadingChange();
+	}
+	setError(error) {
+		this.error = error;
+		this.callbacksRef.onErrorChange?.(error);
+		this.devtoolsBridge.recordErrorChange(error);
+	}
+	setStatus(status) {
+		this.status = status;
+		this.callbacksRef.onStatusChange?.(status);
+		this.devtoolsBridge.recordStatusChange(status);
+	}
+	setProgress(value, message) {
+		this.progress = {
+			value,
+			...message ? { message } : {}
+		};
+		if (message === void 0) this.callbacksRef.onProgress?.(value);
+		else this.callbacksRef.onProgress?.(value, message);
+		this.devtoolsBridge.recordProgressChange();
+	}
+	createCompletedVideoStatus(result) {
+		return {
+			jobId: result.jobId,
+			status: result.status,
+			progress: 100,
+			url: result.url
+		};
+	}
+	createDevtoolsMetadata(metadata) {
+		return {
+			hookName: metadata?.hookName ?? "useGenerateVideo",
+			outputKind: metadata?.outputKind ?? "video",
+			...metadata?.framework ? { framework: metadata.framework } : {},
+			...metadata?.name ? { name: metadata.name } : {}
+		};
+	}
+	generateUniqueId(prefix) {
+		return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+	}
+	createRunContext(runId) {
+		return {
+			threadId: this.threadId,
+			runId
+		};
+	}
+	observeResumeSnapshot(chunk) {
+		this.resumeSnapshot = updateGenerationResumeSnapshot(this.resumeSnapshot, chunk);
+		this.notifyResumeSnapshotChanged();
+	}
+	/** Notify the internal snapshot listener AND emit the public resume state. */
+	notifyResumeSnapshotChanged() {
+		this.callbacksRef.onResumeSnapshotChange?.(this.resumeSnapshot);
+		this.emitResumeState();
+	}
+	/** Derive the public `resumeState` from the internal snapshot. */
+	emitResumeState() {
+		const snapshot = this.resumeSnapshot;
+		const state = snapshot?.resumeState;
+		const resumeState = state ? {
+			...state,
+			...snapshot?.pendingArtifacts && snapshot.pendingArtifacts.length > 0 ? { pendingArtifacts: [...snapshot.pendingArtifacts] } : {}
+		} : null;
+		this.callbacksRef.onResumeStateChange?.(resumeState);
+	}
+	/**
+	* Repaint the normal fields from a restored snapshot so a reload presents the
+	* video in `result` / `status` / `error` / `jobId`, never a snapshot object.
+	* `isLoading` stays false (no auto-tail). Not re-persisted (it came from
+	* storage / the server).
+	*
+	* A `complete` snapshot with no durable video artifact cannot be rebuilt, so
+	* it repaints as an error rather than a `success` with a `null` result — see
+	* the note on `GenerationClient.repaintFromSnapshot`.
+	*/
+	repaintFromSnapshot(snapshot) {
+		this.resumeSnapshot = snapshot;
+		this.notifyResumeSnapshotChanged();
+		this.setStatus(clientStateFromResumeStatus(snapshot.status));
+		this.setError(snapshot.error ? Object.assign(new Error(snapshot.error.message), snapshot.error.code ? { code: snapshot.error.code } : {}) : void 0);
+		if (snapshot.result?.providerJobId) this.setJobId(snapshot.result.providerJobId);
+		const restored = this.reconstructVideoResult(snapshot);
+		if (restored !== null) this.setResult(restored);
+		else if (snapshot.status === "complete") this.reportUnrestorableResult();
+	}
+	/**
+	* Report a `complete` snapshot with no durable video artifact to rebuild
+	* from. Runs after the status/error repaint above, so it wins over the
+	* snapshot's own `complete` status.
+	*/
+	reportUnrestorableResult() {
+		const error = new Error(GENERATION_UNRESTORABLE_RESULT_MESSAGE);
+		this.setStatus("error");
+		this.setError(error);
+		this.callbacksRef.onError?.(error);
+	}
+	/**
+	* Repaint a restored snapshot (client store or server hydrate) and, when it
+	* reports a run still in flight, tail that run to completion via `joinRun`
+	* (from the connection, or the `joinRun` option when the transport can't
+	* carry one).
+	*
+	* A `running` snapshot that no `joinRun` handler can tail is repainted as an
+	* interrupted error instead of a `generating` status that would never
+	* settle: an interrupted generation cannot be resumed, only re-run.
+	*/
+	repaintRestoredSnapshot(snapshot, activeRunId) {
+		if (snapshot.status !== "running") {
+			this.repaintFromSnapshot(snapshot);
+			return;
+		}
+		const joinRun = this.connection?.joinRun ?? this.joinRunHandler;
+		const runId = activeRunId ?? snapshot.resumeState?.runId;
+		if (runId && joinRun) {
+			this.repaintFromSnapshot(snapshot);
+			this.rejoinInFlight(runId);
+			return;
+		}
+		this.repaintFromSnapshot({
+			...snapshot,
+			resumeState: null,
+			status: "error",
+			error: { message: "The previous generation was interrupted before it finished and cannot be resumed — generate again to retry." }
+		});
+	}
+	/**
+	* Rebuild a `VideoGenerateResult` from a restored snapshot: the video's bytes
+	* are served from the durable artifact URL, so the restored result renders
+	* from your own origin. Returns `null` when there is no durable video artifact.
+	*/
+	reconstructVideoResult(snapshot) {
+		const result = snapshot.result;
+		const artifacts = result?.artifacts ?? [];
+		const output = artifacts.find((a) => a.role === "output" && a.source.mediaType === "video" && a.url != null);
+		if (!output?.url) return null;
+		return {
+			jobId: result?.providerJobId ?? "",
+			status: "completed",
+			url: output.url,
+			...result?.expiresAt ? { expiresAt: new Date(result.expiresAt) } : {},
+			artifacts
+		};
+	}
+	/**
+	* The plain (non-Response) fetcher path never observes stream chunks, so
+	* the terminal snapshot is built here from the fetcher's own result. A
+	* stale `error` from a previous run is intentionally dropped — this run
+	* succeeded.
+	*/
+	completePlainFetcherResumeSnapshot(rawResult) {
+		const previous = this.resumeSnapshot;
+		const result = createGenerationResultSnapshot(rawResult);
+		this.resumeSnapshot = {
+			schemaVersion: 1,
+			resumeState: null,
+			status: "complete",
+			...previous?.activity ? { activity: previous.activity } : {},
+			...previous?.pendingArtifacts && previous.pendingArtifacts.length > 0 ? { pendingArtifacts: [...previous.pendingArtifacts] } : {},
+			...result ? { result } : previous?.result ? { result: { ...previous.result } } : {}
+		};
+		this.notifyResumeSnapshotChanged();
+	}
+	/**
+	* Records a transport-level failure (network drop, throwing callback) in
+	* the snapshot. Without this, only a server-emitted RUN_ERROR chunk would
+	* mark the snapshot `error`, leaving a persisted record that claims the
+	* run is still in flight.
+	*/
+	recordResumeSnapshotError(error) {
+		if (this.status !== "error") this.setStatus("error");
+		this.setError(error);
+		if (this.resumeSnapshot?.status === "error") return;
+		if (!this.resumeSnapshot && !this.serverDriven) return;
+		const previous = this.resumeSnapshot;
+		this.resumeSnapshot = {
+			schemaVersion: 1,
+			resumeState: null,
+			status: "error",
+			...previous?.activity ? { activity: previous.activity } : {},
+			...previous?.pendingArtifacts && previous.pendingArtifacts.length > 0 ? { pendingArtifacts: [...previous.pendingArtifacts] } : {},
+			...previous?.result ? { result: { ...previous.result } } : {},
+			error: { message: error.message }
+		};
+		this.notifyResumeSnapshotChanged();
+	}
+	/**
+	* Drop the client's in-memory snapshot and re-emit. Purely local — this
+	* client writes no storage, so nothing persisted is removed.
+	*/
+	clearResumeSnapshot() {
+		this.resumeSnapshot = void 0;
+		this.notifyResumeSnapshotChanged();
+	}
+	/**
+	* Server-driven mount hydration entry point (`persistence: true`). Runs at
+	* most once, from the commit-phase mount path (`mountDevtools`) — never the
+	* constructor / render phase — so remounts and speculative renders can't
+	* re-fire the hydrate GET.
+	*/
+	maybeHydrateFromServer() {
+		if (!this.serverDriven || this.serverHydrationStarted) return;
+		this.serverHydrationStarted = true;
+		if (this.connection?.hydrateGeneration ?? this.hydrateGenerationHandler) this.hydrateFromServer();
+		else console.warn("[TanStack AI] `persistence: true` (server-driven) needs a `hydrateGeneration` handler — either a connection that implements one (e.g. `fetchServerSentEvents` / `fetchHttpStream`, or `stream()` / `rpcStream()` with persistence handlers) or the `hydrateGeneration` option. Without one, nothing is persisted or restored.");
+	}
+	/**
+	* Server-driven mount hydration (`persistence: true`). The client holds no
+	* local snapshot; on mount it asks the server — keyed by the stable threadId —
+	* for the last generation's resume snapshot, validates it, and repaints it. It
+	* never auto-starts a run, and never blocks: a `generate()` that starts first
+	* owns the client and hydration backs off, mirroring the chat client.
+	*
+	* A genuine **miss** (no record for the thread) is silent; a genuine
+	* **failure** (transport error, authorize rejection, malformed body, a record
+	* the validator rejects) surfaces through `status` / `error` / `onError` — see
+	* the note on `GenerationClient.hydrateFromServer`.
+	*/
+	hydrateFromServer() {
+		const hydrate = this.connection?.hydrateGeneration ?? this.hydrateGenerationHandler;
+		if (!hydrate) return;
+		if (this.resumeSnapshot || this.isLoading || this.status !== "idle") return;
+		(async () => {
+			let res;
+			try {
+				res = await hydrate(this.threadId);
+			} catch (cause) {
+				this.failHydration(createGenerationHydrationError("the request to the server did not succeed", cause));
+				return;
+			}
+			if (!res.resumeSnapshot) return;
+			const snapshot = parseGenerationResumeSnapshot(res.resumeSnapshot);
+			if (!snapshot) {
+				this.failHydration(createGenerationHydrationError("the server returned a record this client cannot read (unknown schema version, or a missing/invalid `status` or `resumeState`)"));
+				return;
+			}
+			if (this.resumeSnapshot || this.isLoading || this.status !== "idle") return;
+			this.repaintRestoredSnapshot(snapshot, res.activeRun?.runId);
+		})();
+	}
+	/**
+	* Surface a hydration failure on the observable fields. Skipped when a
+	* `generate()` took ownership while the hydrate GET was in flight.
+	*/
+	failHydration(error) {
+		if (this.resumeSnapshot || this.isLoading || this.status !== "idle") return;
+		this.setStatus("error");
+		this.setError(error);
+		this.callbacksRef.onError?.(error);
+	}
+	/**
+	* Re-attach to an already-loaded `running` snapshot (remount case); see the
+	* note in GenerationClient.maybeResumeInFlight. Guarded by `rejoinInFlight`.
+	*/
+	maybeResumeInFlight() {
+		if (this.resumeSnapshot?.status !== "running") return;
+		const runId = this.resumeSnapshot.resumeState?.runId;
+		if (runId) this.rejoinInFlight(runId);
+	}
+	/**
+	* Re-attach to a video run still generating and stream it to completion,
+	* mirroring the chat client's mount-time rejoin. Reuses `processStream`, so
+	* the job status and result repaint from the replayed chunks. A live
+	* `generate()` owns the client and is never stomped; a run is rejoined once.
+	*/
+	rejoinInFlight(runId) {
+		const joinRun = this.connection?.joinRun ?? this.joinRunHandler;
+		if (!joinRun) return;
+		if (this.rejoinedRunId === runId) return;
+		if (this.isLoading || this.abortController) return;
+		this.rejoinedRunId = runId;
+		const controller = new AbortController();
+		this.abortController = controller;
+		this.setIsLoading(true);
+		this.setStatus("generating");
+		(async () => {
+			try {
+				await this.processStream(joinRun(runId, controller.signal), runId, controller.signal);
+			} catch (error) {
+				if (!controller.signal.aborted) {
+					const failure = error instanceof Error ? error : new Error(String(error));
+					this.recordResumeSnapshotError(failure);
+					this.callbacksRef.onError?.(failure);
+				}
+			} finally {
+				if (this.abortController === controller) {
+					this.abortController = null;
+					this.setIsLoading(false);
+				}
+			}
+		})();
+	}
 };
-//# sourceMappingURL=video-generation-client.js.map
+//#endregion
+export { VideoGenerationClient };
+
+//# sourceMappingURL=video-generation-client.js.map