@xfey/tutti 0.1.53 → 0.1.54

package/dist/artifacts/preview-runtime.js

@@ -2,11 +2,12 @@ import { lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { redactAndTruncateText } from "@tutti/shared/utils";
 import { WorkspaceOpsError } from "../workspace-ops/errors.js";
-import { ARTIFACT_PREVIEW_BASE_PATH, readArtifactDeclaration, } from "./manifest.js";
+import { readLiveArtifactDeclaration, } from "./live-manifest.js";
 import { allocateArtifactPreviewPort, ArtifactDiagnosticBuffer, cleanupArtifactProcessRuntime, createArtifactPreviewEnv, createArtifactProcessRuntime, spawnArtifactPreviewProcess, terminateArtifactProcessTree, } from "./process-boundary.js";
-import { rewriteArtifactPreviewResourceUrls } from "./static-preview.js";
+import { readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, } from "./static-preview.js";
 export const ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES = 1024 * 1024;
 export const ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES = 5 * 1024 * 1024;
+export const ARTIFACT_PREVIEW_BASE_PATH = "/artifacts/preview";
 const DEFAULT_READY_TIMEOUT_MS = 20_000;
 const DEFAULT_READY_PROBE_INTERVAL_MS = 250;
 const DEFAULT_READY_PROBE_REQUEST_TIMEOUT_MS = 2_000;
@@ -44,64 +45,54 @@ const RESPONSE_HEADER_DENYLIST = new Set([
     "www-authenticate",
 ]);
 const SENSITIVE_RESPONSE_HEADER_PATTERN = /authorization|cookie|credential|proxy-auth|secret|token|x-api[-_]?key/iu;
-function isServerDeclaration(declaration) {
-    return declaration.status === "declared" && declaration.runtime.kind === "server";
-}
-function serverDeclarationKey(declaration) {
-    return [
-        declaration.snapshot_oid,
-        declaration.manifest_blob_oid,
-        declaration.runtime.cwd_path,
-        declaration.runtime.entry_path,
-    ].join(":");
-}
 function buildServerPreviewUrl(options) {
     const basePath = (options.basePath ?? ARTIFACT_PREVIEW_BASE_PATH).replace(/\/+$/u, "");
     const normalizedEntryPath = options.entryPath === "/" ? "/" : `/${options.entryPath.replace(/^\/+/, "")}`;
     const separator = normalizedEntryPath.includes("?") ? "&" : "?";
-    return `${basePath}${normalizedEntryPath}${separator}v=${encodeURIComponent(options.manifestBlobOid)}&preview=${encodeURIComponent(options.instanceId)}`;
+    return `${basePath}${normalizedEntryPath}${separator}g=${encodeURIComponent(options.generation)}`;
 }
-function declarationInvalidDisposition(declaration) {
-    const disposition = {
-        kind: "invalid_manifest",
-        message: declaration.projection.error.message,
-    };
-    return {
-        start: disposition,
-        heartbeat: disposition,
-        stop: disposition,
-    };
+function buildStaticPreviewUrl(options) {
+    const basePath = (options.basePath ?? ARTIFACT_PREVIEW_BASE_PATH).replace(/\/+$/u, "");
+    const encodedEntryPath = options.entryPath
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+    const path = encodedEntryPath.length === 0 ? basePath : `${basePath}/${encodedEntryPath}`;
+    return `${path}?g=${encodeURIComponent(options.generation)}`;
 }
-function projectionWithServerState(options) {
+function projectionWithState(options) {
     const artifact = options.declaration.manifest.artifact;
     const baseProjection = {
         status: "declared",
-        manifest_path: "tutti.artifact.json",
-        manifest_blob_oid: options.declaration.manifest_blob_oid,
+        preview_generation: options.state.generation,
         artifact: {
             title: artifact.title,
-            kind: "server",
+            kind: artifact.kind,
             network: artifact.network,
         },
         preview: {
-            status: "stopped",
+            status: "idle",
         },
     };
     const state = options.state;
-    if (state === undefined || state.key !== serverDeclarationKey(options.declaration)) {
-        return baseProjection;
-    }
     if (state.status === "ready") {
+        const url = artifact.kind === "static" && options.declaration.runtime.kind === "static"
+            ? buildStaticPreviewUrl({
+                basePath: options.previewBasePath,
+                entryPath: options.declaration.runtime.entry_path,
+                generation: state.generation,
+            })
+            : buildServerPreviewUrl({
+                basePath: options.previewBasePath,
+                entryPath: state.entryPath,
+                generation: state.generation,
+            });
         return {
             ...baseProjection,
             preview: {
                 status: "ready",
-                url: buildServerPreviewUrl({
-                    basePath: options.previewBasePath,
-                    entryPath: state.entryPath,
-                    manifestBlobOid: state.manifestBlobOid,
-                    instanceId: state.instanceId,
-                }),
+                url,
             },
         };
     }
@@ -215,8 +206,7 @@ function safeRedirectLocation(options) {
     if (redirected.origin !== options.localUrl.origin) {
         throw new WorkspaceOpsError("validation_failed", "Artifact preview redirect left the managed preview instance");
     }
-    redirected.searchParams.set("v", options.state.manifestBlobOid);
-    redirected.searchParams.set("preview", options.state.instanceId);
+    redirected.searchParams.set("g", options.state.generation);
     return `${ARTIFACT_PREVIEW_BASE_PATH}${redirected.pathname}${redirected.search}${redirected.hash}`;
 }
 function unrefTimer(timer) {
@@ -237,7 +227,6 @@ export function isArtifactPreviewHttpMethod(method) {
         method === "OPTIONS");
 }
 export class ArtifactPreviewManager {
-    now;
     baseEnv;
     spawnProcess;
     terminateProcess;
@@ -257,10 +246,14 @@ export class ArtifactPreviewManager {
     responseBodyLimitBytes;
     idleStopTtlMs;
     pendingTasks = new Set();
+    leases = new Map();
+    leaseSweepTimer;
     state;
-    nextInstanceSequence = 0;
+    declaration;
+    lastProjection = { status: "not_declared" };
+    workspaceUpdating = false;
+    nextGenerationSequence = 0;
     constructor(options = {}) {
-        this.now = options.now ?? (() => new Date());
         this.baseEnv = options.baseEnv ?? process.env;
         this.spawnProcess = options.spawnProcess ?? spawnArtifactPreviewProcess;
         this.terminateProcess = options.terminateProcess ?? terminateArtifactProcessTree;
@@ -283,187 +276,40 @@ export class ArtifactPreviewManager {
             options.responseBodyLimitBytes ?? ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES;
         this.idleStopTtlMs = options.idleStopTtlMs ?? DEFAULT_IDLE_STOP_TTL_MS;
     }
-    readProjection(options) {
-        const declaration = readArtifactDeclaration({
-            workspaceRoot: options.workspaceRoot,
-            previewBasePath: options.previewBasePath,
-            now: this.now,
-        });
-        this.stopStaleRuntime(declaration);
-        return {
-            artifact: isServerDeclaration(declaration)
-                ? projectionWithServerState({
-                    declaration,
-                    state: this.state,
-                    previewBasePath: options.previewBasePath,
-                })
-                : declaration.projection,
-        };
-    }
-    start(options) {
-        const declaration = readArtifactDeclaration({
-            workspaceRoot: options.workspaceRoot,
-            previewBasePath: options.previewBasePath,
-            now: this.now,
-        });
-        this.stopStaleRuntime(declaration);
-        if (declaration.status === "not_declared") {
-            return {
-                disposition: { kind: "not_declared" },
-                result: { artifact: declaration.projection },
-            };
-        }
-        if (declaration.status === "invalid") {
-            return {
-                disposition: declarationInvalidDisposition(declaration).start,
-                result: { artifact: declaration.projection },
-            };
-        }
-        if (!isServerDeclaration(declaration)) {
-            return {
-                disposition: { kind: "unsupported" },
-                result: { artifact: declaration.projection },
-            };
-        }
-        const key = serverDeclarationKey(declaration);
-        if (this.state?.key === key) {
-            if (this.state.status === "ready") {
-                this.recordHeartbeat(this.state);
-                return {
-                    disposition: { kind: "already_running" },
-                    result: {
-                        artifact: projectionWithServerState({
-                            declaration,
-                            state: this.state,
-                            previewBasePath: options.previewBasePath,
-                        }),
-                    },
-                };
-            }
-            if (this.state.status === "starting") {
-                this.recordHeartbeat(this.state);
-                return {
-                    disposition: { kind: "starting" },
-                    result: {
-                        artifact: projectionWithServerState({
-                            declaration,
-                            state: this.state,
-                            previewBasePath: options.previewBasePath,
-                        }),
-                    },
-                };
-            }
-            this.stopCurrentProcess();
+    readProjection(options = {}) {
+        if (this.declaration === undefined && options.workspaceRoot !== undefined) {
+            this.initializeWorkspace({ workspaceRoot: options.workspaceRoot });
         }
-        this.startProcess(options.workspaceRoot, declaration);
         return {
-            disposition: { kind: "started" },
-            result: {
-                artifact: projectionWithServerState({
-                    declaration,
-                    state: this.state,
-                    previewBasePath: options.previewBasePath,
-                }),
-            },
+            artifact: this.currentProjection(options.previewBasePath),
         };
     }
-    heartbeat(options) {
-        const declaration = readArtifactDeclaration({
-            workspaceRoot: options.workspaceRoot,
-            previewBasePath: options.previewBasePath,
-            now: this.now,
-        });
-        this.stopStaleRuntime(declaration);
-        if (declaration.status === "not_declared") {
-            return {
-                disposition: { kind: "not_declared" },
-                result: { artifact: declaration.projection },
-            };
-        }
-        if (declaration.status === "invalid") {
-            return {
-                disposition: declarationInvalidDisposition(declaration).heartbeat,
-                result: { artifact: declaration.projection },
-            };
-        }
-        if (!isServerDeclaration(declaration) ||
-            this.state?.key !== serverDeclarationKey(declaration)) {
-            return {
-                disposition: { kind: "not_running" },
-                result: {
-                    artifact: isServerDeclaration(declaration)
-                        ? projectionWithServerState({
-                            declaration,
-                            state: this.state,
-                            previewBasePath: options.previewBasePath,
-                        })
-                        : declaration.projection,
-                },
-            };
-        }
-        if (this.state.status !== "starting" && this.state.status !== "ready") {
-            return {
-                disposition: { kind: "not_running" },
-                result: {
-                    artifact: projectionWithServerState({
-                        declaration,
-                        state: this.state,
-                        previewBasePath: options.previewBasePath,
-                    }),
-                },
-            };
+    initializeWorkspace(options) {
+        if (this.declaration !== undefined || this.state !== undefined) {
+            return;
         }
-        this.recordHeartbeat(this.state);
-        return {
-            disposition: { kind: "recorded" },
-            result: {
-                artifact: projectionWithServerState({
-                    declaration,
-                    state: this.state,
-                    previewBasePath: options.previewBasePath,
-                }),
-            },
-        };
+        this.refreshDeclaration(options.workspaceRoot, false, false);
     }
-    stop(options) {
-        const declaration = readArtifactDeclaration({
-            workspaceRoot: options.workspaceRoot,
-            previewBasePath: options.previewBasePath,
-            now: this.now,
-        });
-        if (declaration.status === "not_declared") {
-            this.stopCurrentProcess();
-            return {
-                disposition: { kind: "not_declared" },
-                result: { artifact: declaration.projection },
-            };
-        }
-        if (declaration.status === "invalid") {
-            this.stopCurrentProcess();
-            return {
-                disposition: declarationInvalidDisposition(declaration).stop,
-                result: { artifact: declaration.projection },
-            };
+    renewLease(options) {
+        const nowMs = this.clockMs();
+        this.pruneExpiredLeases(nowMs);
+        const hadActiveLease = this.leases.size > 0;
+        this.leases.set(options.viewerId, nowMs);
+        this.scheduleLeaseSweep(nowMs);
+        if (!hadActiveLease) {
+            this.ensurePreview(options.workspaceRoot);
         }
-        if (!isServerDeclaration(declaration) ||
-            this.state?.key !== serverDeclarationKey(declaration)) {
-            return {
-                disposition: { kind: "not_running" },
-                result: { artifact: declaration.projection },
-            };
+    }
+    beginWorkspaceUpdate() {
+        if (this.workspaceUpdating) {
+            return;
         }
-        const wasRunning = this.state.status === "starting" || this.state.status === "ready";
+        this.workspaceUpdating = true;
         this.stopCurrentProcess();
-        return {
-            disposition: wasRunning ? { kind: "stopped" } : { kind: "not_running" },
-            result: {
-                artifact: projectionWithServerState({
-                    declaration,
-                    state: this.state,
-                    previewBasePath: options.previewBasePath,
-                }),
-            },
-        };
+    }
+    settleWorkspaceUpdate(options) {
+        this.workspaceUpdating = false;
+        this.refreshDeclaration(options.workspaceRoot, this.leases.size > 0);
     }
     async fetchServerPreview(options) {
         if (options.body !== undefined && options.body.byteLength > this.requestBodyLimitBytes) {
@@ -472,13 +318,8 @@ export class ArtifactPreviewManager {
         if ((options.method === "GET" || options.method === "HEAD") && options.body !== undefined) {
             throw new WorkspaceOpsError("bad_request", "Artifact preview request method cannot have a body");
         }
-        const declaration = readArtifactDeclaration({
-            workspaceRoot: options.workspaceRoot,
-            now: this.now,
-        });
-        this.stopStaleRuntime(declaration);
         const state = this.state;
-        if (!isServerDeclaration(declaration) || state?.key !== serverDeclarationKey(declaration)) {
+        if (state?.declaration.runtime.kind !== "server") {
             throw new WorkspaceOpsError("not_found", "Artifact preview is not running");
         }
         if (state.status !== "ready" || state.port === undefined || !processIsAlive(state.child)) {
@@ -490,16 +331,11 @@ export class ArtifactPreviewManager {
         const requestPath = normalizePreviewRequestPath(options.path);
         const localUrl = new URL(`http://127.0.0.1:${state.port}${requestPath}`);
         const query = new URLSearchParams(options.query?.replace(/^\?/u, "") ?? "");
-        const requestedManifestBlobOid = query.get("v");
-        if (requestedManifestBlobOid !== null && requestedManifestBlobOid !== state.manifestBlobOid) {
-            throw new WorkspaceOpsError("not_found", "Artifact preview manifest is stale");
-        }
-        const requestedInstanceId = query.get("preview");
-        if (requestedInstanceId !== null && requestedInstanceId !== state.instanceId) {
-            throw new WorkspaceOpsError("not_found", "Artifact preview instance is stale");
+        const requestedGeneration = query.get("g");
+        if (requestedGeneration !== state.generation) {
+            throw new WorkspaceOpsError("not_found", "Artifact preview generation is stale");
         }
-        query.delete("v");
-        query.delete("preview");
+        query.delete("g");
         localUrl.search = query.toString();
         const requestHeaders = sanitizeRequestHeaders(options.headers);
         if (options.headers?.origin !== undefined) {
@@ -551,41 +387,142 @@ export class ArtifactPreviewManager {
             this.clearTimeoutFn(timeout);
         }
     }
-    sweepIdle() {
-        if (this.state === undefined || this.state.status === "stopped") {
-            return;
+    readStaticPreview(options) {
+        const state = this.state;
+        if (state?.declaration.runtime.kind !== "static" ||
+            state.status !== "ready" ||
+            this.workspaceUpdating) {
+            throw new WorkspaceOpsError("not_found", "Artifact preview is not ready");
         }
-        if (this.clockMs() - this.state.lastHeartbeatAtMs < this.idleStopTtlMs) {
-            this.scheduleIdleSweep(this.state);
-            return;
+        const query = new URLSearchParams(options.query?.replace(/^\?/u, "") ?? "");
+        const requestedGeneration = query.get("g");
+        if (requestedGeneration !== state.generation) {
+            throw new WorkspaceOpsError("not_found", "Artifact preview generation is stale");
         }
-        this.stopCurrentProcess();
+        return readArtifactStaticPreview({
+            workspaceRoot: options.workspaceRoot,
+            path: options.path,
+            declaration: state.declaration,
+        });
     }
     async stopAll() {
+        this.leases.clear();
+        if (this.leaseSweepTimer !== undefined) {
+            this.clearTimeoutFn(this.leaseSweepTimer);
+            this.leaseSweepTimer = undefined;
+        }
         this.stopCurrentProcess();
         while (this.pendingTasks.size > 0) {
             await Promise.all([...this.pendingTasks]);
         }
     }
+    currentProjection(previewBasePath) {
+        const state = this.state;
+        return state === undefined
+            ? this.lastProjection
+            : projectionWithState({
+                declaration: state.declaration,
+                state,
+                ...(previewBasePath === undefined ? {} : { previewBasePath }),
+            });
+    }
+    ensurePreview(workspaceRoot) {
+        const current = this.state;
+        if (this.workspaceUpdating && current !== undefined) {
+            return current.declaration;
+        }
+        if (current !== undefined &&
+            (current.status === "starting" ||
+                current.status === "ready" ||
+                current.status === "failed")) {
+            return current.declaration;
+        }
+        const declaration = current?.declaration ?? this.declaration;
+        if (declaration !== undefined) {
+            return this.applyDeclaration(workspaceRoot, declaration, true);
+        }
+        return this.refreshDeclaration(workspaceRoot, true);
+    }
+    refreshDeclaration(workspaceRoot, activate, notify = true) {
+        const declaration = readLiveArtifactDeclaration({ workspaceRoot });
+        this.declaration = declaration;
+        return this.applyDeclaration(workspaceRoot, declaration, activate, notify);
+    }
+    applyDeclaration(workspaceRoot, declaration, activate, notify = true) {
+        if (this.state !== undefined) {
+            this.stopCurrentProcess();
+            this.state = undefined;
+        }
+        if (declaration.status !== "declared") {
+            this.lastProjection = declaration.projection;
+            if (notify) {
+                this.onStatusChange();
+            }
+            return declaration;
+        }
+        if (!activate) {
+            const state = this.createIdleState(declaration);
+            this.state = state;
+            this.lastProjection = projectionWithState({ declaration, state });
+            if (notify) {
+                this.onStatusChange();
+            }
+            return declaration;
+        }
+        if (declaration.runtime.kind === "server") {
+            this.startProcess(workspaceRoot, declaration);
+            return declaration;
+        }
+        const generation = this.nextGeneration();
+        const state = {
+            generation,
+            declaration,
+            entryPath: declaration.runtime.entry_path,
+            cwdPath: "",
+            status: "ready",
+            child: undefined,
+            processRuntime: undefined,
+            port: undefined,
+            launchAttempt: 0,
+            errorMessage: undefined,
+            diagnostics: new ArtifactDiagnosticBuffer(),
+        };
+        this.state = state;
+        this.lastProjection = projectionWithState({ declaration, state });
+        this.onStatusChange();
+        return declaration;
+    }
+    createIdleState(declaration) {
+        return {
+            generation: this.nextGeneration(),
+            declaration,
+            entryPath: declaration.runtime.entry_path,
+            cwdPath: "",
+            status: "idle",
+            child: undefined,
+            processRuntime: undefined,
+            port: undefined,
+            launchAttempt: 0,
+            errorMessage: undefined,
+            diagnostics: new ArtifactDiagnosticBuffer(),
+        };
+    }
     startProcess(workspaceRoot, declaration) {
+        const generation = this.nextGeneration();
         const state = {
-            key: serverDeclarationKey(declaration),
-            manifestBlobOid: declaration.manifest_blob_oid,
+            generation,
+            declaration,
             entryPath: declaration.runtime.entry_path,
             cwdPath: resolveServerCwd(workspaceRoot, declaration.runtime.cwd_path),
             status: "starting",
             child: undefined,
             processRuntime: undefined,
             port: undefined,
-            instanceId: this.nextInstanceId(),
             launchAttempt: 0,
-            lastHeartbeatAtMs: this.clockMs(),
             errorMessage: undefined,
             diagnostics: new ArtifactDiagnosticBuffer(),
-            idleTimer: undefined,
         };
         this.state = state;
-        this.scheduleIdleSweep(state);
         this.onStatusChange();
         this.trackTask(this.launchProcess(state));
     }
@@ -633,7 +570,7 @@ export class ArtifactPreviewManager {
             }
         });
         child.on("close", (code, signal) => {
-            if (this.state !== state || state.child !== child || state.status === "stopped") {
+            if (this.state !== state || state.child !== child || state.status === "idle") {
                 this.cleanupStateRuntime(state, runtime);
                 return;
             }
@@ -746,50 +683,55 @@ export class ArtifactPreviewManager {
         }
         return { kind: "invalid", message: "Preview entry redirected too many times" };
     }
-    recordHeartbeat(state) {
-        state.lastHeartbeatAtMs = this.clockMs();
-        this.scheduleIdleSweep(state);
-    }
-    scheduleIdleSweep(state) {
-        if (state.idleTimer !== undefined) {
-            this.clearTimeoutFn(state.idleTimer);
+    pruneExpiredLeases(nowMs) {
+        for (const [viewerId, renewedAtMs] of this.leases) {
+            if (nowMs - renewedAtMs >= this.idleStopTtlMs) {
+                this.leases.delete(viewerId);
+            }
         }
-        state.idleTimer = this.setTimeoutFn(() => this.sweepIdle(), this.idleStopTtlMs);
-        unrefTimer(state.idleTimer);
     }
-    stopStaleRuntime(declaration) {
-        if (this.state === undefined) {
-            return;
+    scheduleLeaseSweep(nowMs = this.clockMs()) {
+        if (this.leaseSweepTimer !== undefined) {
+            this.clearTimeoutFn(this.leaseSweepTimer);
+            this.leaseSweepTimer = undefined;
         }
-        if (!isServerDeclaration(declaration) || this.state.key !== serverDeclarationKey(declaration)) {
-            this.stopCurrentProcess();
-            this.state = undefined;
+        if (this.leases.size === 0) {
+            return;
         }
+        let earliestExpiryMs = Number.POSITIVE_INFINITY;
+        for (const renewedAtMs of this.leases.values()) {
+            earliestExpiryMs = Math.min(earliestExpiryMs, renewedAtMs + this.idleStopTtlMs);
+        }
+        this.leaseSweepTimer = this.setTimeoutFn(() => {
+            this.leaseSweepTimer = undefined;
+            const sweepAtMs = this.clockMs();
+            this.pruneExpiredLeases(sweepAtMs);
+            if (this.leases.size === 0) {
+                if (this.state?.status !== "failed") {
+                    this.stopCurrentProcess();
+                }
+                return;
+            }
+            this.scheduleLeaseSweep(sweepAtMs);
+        }, Math.max(0, earliestExpiryMs - nowMs));
+        unrefTimer(this.leaseSweepTimer);
     }
     stopCurrentProcess() {
         const state = this.state;
-        if (state === undefined) {
+        if (state === undefined || state.status === "idle") {
             return;
         }
-        if (state.idleTimer !== undefined) {
-            this.clearTimeoutFn(state.idleTimer);
-            state.idleTimer = undefined;
-        }
         this.disposeStateProcess(state);
-        state.status = "stopped";
+        state.status = "idle";
         state.errorMessage = undefined;
         this.onStatusChange();
     }
     failState(state, message) {
-        if (this.state !== state || state.status === "stopped") {
+        if (this.state !== state || state.status === "idle") {
             return;
         }
         state.status = "failed";
         state.errorMessage = redactAndTruncateText(message, 220);
-        if (state.idleTimer !== undefined) {
-            this.clearTimeoutFn(state.idleTimer);
-            state.idleTimer = undefined;
-        }
         this.disposeStateProcess(state);
         this.onStatusChange();
     }
@@ -822,9 +764,9 @@ export class ArtifactPreviewManager {
         this.pendingTasks.add(task);
         void task.finally(() => this.pendingTasks.delete(task));
     }
-    nextInstanceId() {
-        this.nextInstanceSequence += 1;
-        return `artifact_preview_${this.nextInstanceSequence}`;
+    nextGeneration() {
+        this.nextGenerationSequence += 1;
+        return `artifact_preview_${this.nextGenerationSequence}`;
     }
 }
 export const ARTIFACT_PREVIEW_DEFAULT_BASE_PATH = ARTIFACT_PREVIEW_BASE_PATH;

package/dist/artifacts/static-preview.d.ts

@@ -1,3 +1,4 @@
+import { type LiveArtifactDeclaration } from "./live-manifest.js";
 export declare const ARTIFACT_PREVIEW_CSP: string;
 export type ArtifactStaticPreviewFile = {
     media_type: string;
@@ -6,7 +7,7 @@ export type ArtifactStaticPreviewFile = {
 export type ReadArtifactStaticPreviewOptions = {
     workspaceRoot: string;
     path: string | undefined;
-    now?: () => Date;
+    declaration?: LiveArtifactDeclaration;
 };
 export declare function rewriteArtifactPreviewResourceUrls(options: {
     mediaType: string | undefined;