@mieweb/pulsevault 0.4.2 → 0.6.0

package/dist/core.js

@@ -1,10 +1,14 @@
 import send from '@fastify/send';
-import { createPulsevaultTusServer, pulseVaultTusContext, artifactIdFromUploadId, } from './lib/pulsevaultTus.js';
+import { fstat, ReadStream } from 'node:fs';
+import { createPulsevaultTusServer, pulseVaultTusContext, artifactIdFromUploadId, normalizeArtifactName, } from './lib/pulsevaultTus.js';
+import { createCompletionRunner, validateCompletionOptions, } from './lib/completion.js';
 import { startRetentionSweep, validateRetentionOptions, } from './lib/retention.js';
 import { pulseVaultError, statusCodeOf } from './lib/errors.js';
 import { isUuid } from './lib/uuid.js';
+import { webReadyAvailable } from './lib/web-ready.js';
 import { consoleLogger } from './lib/request.js';
-import { parseUploadKind } from './storage/types.js';
+import { parseUploadKind, uploadIdOf } from './storage/types.js';
+import { normalizeAppVersion } from './lib/protocol.js';
 import { normalizeAllowedExtensions, validateBasePath, validateMaxUploadSize, rejectRemovedOptions, validateAllowedExtensions, warnIfUsingDeprecatedProjectHooks, composeValidatePayload, composeOnUploadComplete, } from './lib/options.js';
 import { buildCapabilities, PROTOCOL_VERSION } from './lib/capabilities.js';
 import { outdatedClientRejection } from './lib/protocol.js';
@@ -28,6 +32,9 @@ function parseUploadMetadata(header) {
     let projectidRaw;
     let kind = 'video';
     let relatedTo;
+    let filename;
+    let name;
+    let appVersion;
     for (const pair of header.split(',')) {
         const trimmed = pair.trim();
         if (!trimmed)
@@ -56,6 +63,15 @@ function parseUploadMetadata(header) {
             else if (key === 'relatedTo' && !relatedTo) {
                 relatedTo = isUuid(decoded) ? decoded : undefined;
             }
+            else if (key === 'filename') {
+                filename ??= decoded.trim() || undefined;
+            }
+            else if (key === 'name') {
+                name ??= normalizeArtifactName(decoded);
+            }
+            else if (key === 'appVersion') {
+                appVersion ??= normalizeAppVersion(decoded);
+            }
         }
         catch {
             // ignore malformed base64
@@ -63,7 +79,65 @@ function parseUploadMetadata(header) {
     }
     const candidate = (artifactIdRaw ?? videoidRaw ?? projectidRaw ?? '').trim();
     const artifactId = isUuid(candidate) ? candidate : undefined;
-    return { artifactId, kind, relatedTo };
+    return { artifactId, kind, relatedTo, filename, name, appVersion };
+}
+/** Lowercase extension of a filename, with the leading dot; `undefined` when it has none. */
+function extensionOf(filename) {
+    if (!filename)
+        return undefined;
+    const dot = filename.lastIndexOf('.');
+    return dot > 0 ? filename.slice(dot).toLowerCase() : undefined;
+}
+/**
+ * Whether a file stream from `@fastify/send` opened something other than the file `send`
+ * described in its headers (`stat`): the file is gone, or another file was renamed onto the
+ * path in between (a conversion replacing the bytes). Then the stream is closed and nothing has
+ * been written. Streams that aren't file streams (an empty body for a `304`) resolve `false`.
+ */
+async function fileChanged(stream, stat) {
+    if (!(stream instanceof ReadStream))
+        return false;
+    if (stream.pending) {
+        const gone = await new Promise((resolve, reject) => {
+            const onReady = () => {
+                stream.off('error', onError);
+                resolve(false);
+            };
+            const onError = (err) => {
+                stream.off('ready', onReady);
+                // Any other failure to open is the server's, before anything was written: a 500.
+                if (err.code === 'ENOENT')
+                    resolve(true);
+                else
+                    reject(err);
+            };
+            stream.once('ready', onReady);
+            stream.once('error', onError);
+        });
+        if (gone)
+            return true;
+    }
+    // The descriptor the stream opened (set once it's `ready`; not in the type definitions).
+    const fd = stream.fd;
+    if (!stat || typeof fd !== 'number')
+        return false;
+    const opened = await new Promise((resolve, reject) => fstat(fd, (err, st) => (err ? reject(err) : resolve(st))));
+    const same = opened.ino === stat.ino && opened.dev === stat.dev && opened.size === stat.size && opened.mtimeMs === stat.mtimeMs;
+    if (!same)
+        stream.destroy();
+    return !same;
+}
+/** The hook-context fields that come from stored metadata, for every phase after `create`. */
+function describedFields(meta) {
+    if (!meta)
+        return {};
+    return {
+        ...(meta.name ? { name: meta.name } : {}),
+        ...(meta.appVersion ? { appVersion: meta.appVersion } : {}),
+        filename: meta.filename,
+        ext: meta.sourceExt ?? meta.ext,
+        ...(meta.context !== undefined ? { context: meta.context } : {}),
+    };
 }
 /**
  * `@tus/server`'s `BaseHandler.getFileIdFromRequest` — the function that
@@ -203,6 +277,29 @@ export function createPulseVaultCore(options) {
             await onArtifactEvent?.({ phase: 'remove', artifactId, kind, reason: 'abandoned' });
         })
         : null;
+    const pulseShape = options.pulseShape ?? true;
+    const lockWhenReady = options.lockWhenReady === true;
+    const describe = (artifactId) => typeof storage.describeArtifact === 'function'
+        ? storage.describeArtifact(artifactId)
+        : Promise.resolve(null);
+    if (options.reclaim !== undefined && options.reclaim !== false) {
+        const { idleSeconds } = options.reclaim;
+        if (idleSeconds !== undefined && !(idleSeconds >= 0 && Number.isFinite(idleSeconds))) {
+            throw new TypeError('`reclaim.idleSeconds` must be a number of seconds, at least 0');
+        }
+    }
+    const reclaim = options.reclaim === false ? false : { idleSeconds: options.reclaim?.idleSeconds ?? 300 };
+    const replay = options.replayCompletions === false ? false : (options.replayCompletions ?? {});
+    validateCompletionOptions({ storage, webReady: options.webReady, replay });
+    const completion = createCompletionRunner({
+        storage,
+        onUploadComplete,
+        onArtifactEvent,
+        webReady: options.webReady,
+        replay,
+        logger,
+    });
+    completion.start();
     const tusPath = `${basePath}/upload`;
     const tusServer = createPulsevaultTusServer({
         storage,
@@ -210,10 +307,36 @@ export function createPulseVaultCore(options) {
         maxSize: maxUploadSize,
         allowedExtensions,
         validatePayload,
-        onUploadComplete,
+        completion,
         onArtifactEvent,
+        pulseShape,
+        reclaim,
+        ...(lockWhenReady ? { isLocked: (artifactId) => isLocked(artifactId) } : {}),
         logger,
     });
+    /**
+     * With `lockWhenReady`, whether a delete must be refused: the artifact is finished, or it
+     * belongs to a finished video. The check reads storage just before the removal; the TUS
+     * `DELETE` additionally runs under tus's per-upload lock, so it can't interleave with the
+     * final chunk of the same upload.
+     */
+    const isFinished = async (artifactId) => {
+        // `describeArtifact` reads storage itself; `resolve` may answer from a per-instance cache
+        // that hasn't seen another instance finish the upload.
+        if (typeof storage.describeArtifact === 'function') {
+            return (await storage.describeArtifact(artifactId))?.ready ?? false;
+        }
+        return (await storage.resolve(artifactId)) !== null;
+    };
+    const isLocked = async (artifactId, relatedTo) => {
+        if (!lockWhenReady)
+            return false;
+        const meta = await describe(artifactId);
+        if (meta ? meta.ready : await isFinished(artifactId))
+            return true;
+        const parent = relatedTo ?? meta?.relatedTo ?? (await resolveStorageRelatedTo(storage, artifactId));
+        return parent !== undefined && (await isFinished(parent));
+    };
     /**
      * Run the consumer's `authorize` hook (if any) for a TUS request. Returns
      * `true` iff the request may proceed; on rejection, this function already
@@ -223,17 +346,27 @@ export function createPulseVaultCore(options) {
         let artifactId;
         let kind = 'video';
         let relatedTo;
+        let fields = {};
         if (phase === 'create') {
             const meta = req.headers['upload-metadata'];
             if (typeof meta === 'string') {
-                ({ artifactId, kind, relatedTo } = parseUploadMetadata(meta));
+                const parsed = parseUploadMetadata(meta);
+                ({ artifactId, kind, relatedTo } = parsed);
+                fields = {
+                    ...(parsed.name ? { name: parsed.name } : {}),
+                    ...(parsed.appVersion ? { appVersion: parsed.appVersion } : {}),
+                    ...(parsed.filename ? { filename: parsed.filename } : {}),
+                    ...(extensionOf(parsed.filename) ? { ext: extensionOf(parsed.filename) } : {}),
+                };
             }
         }
         else {
             artifactId = artifactIdFromTusUrl(req.url ?? '');
             if (artifactId) {
-                kind = await resolveStorageKind(storage, artifactId);
-                relatedTo = await resolveStorageRelatedTo(storage, artifactId);
+                const described = await describe(artifactId);
+                kind = described?.kind ?? (await resolveStorageKind(storage, artifactId));
+                relatedTo = described?.relatedTo ?? (await resolveStorageRelatedTo(storage, artifactId));
+                fields = describedFields(described);
             }
         }
         if (artifactId) {
@@ -254,8 +387,9 @@ export function createPulseVaultCore(options) {
             return { ok: true, artifactId, kind, relatedTo };
         }
         try {
-            await authorize(req, { phase, artifactId, kind, relatedTo });
-            return { ok: true, artifactId, kind, relatedTo };
+            const result = await authorize(req, { phase, artifactId, kind, relatedTo, ...fields });
+            const context = phase === 'create' && result ? result.context : undefined;
+            return { ok: true, artifactId, kind, relatedTo, ...(context !== undefined ? { context } : {}) };
         }
         catch (err) {
             const statusCode = statusCodeOf(err, 403);
@@ -311,7 +445,13 @@ export function createPulseVaultCore(options) {
             const authz = await runAuthorize(req, res, phase);
             if (!authz.ok)
                 return;
-            await pulseVaultTusContext.run({ request: req, artifactId: authz.artifactId }, () => tusServer.handle(req, res));
+            // `lockWhenReady` for a TUS DELETE is checked inside the datastore's removal, under tus's
+            // per-upload lock (see `withArtifactRemoval`).
+            await pulseVaultTusContext.run({
+                request: req,
+                artifactId: authz.artifactId,
+                ...(authz.context !== undefined ? { context: authz.context } : {}),
+            }, () => tusServer.handle(req, res));
         }
         catch (err) {
             failClosed(res, err, 'tus handler');
@@ -337,13 +477,21 @@ export function createPulseVaultCore(options) {
             writeJson(res, 400, pulseVaultError('`artifactId` must be a valid UUID'));
             return undefined;
         }
-        const kind = await resolveStorageKind(storage, artifactId);
-        const relatedTo = await resolveStorageRelatedTo(storage, artifactId);
+        const described = await describe(artifactId);
+        const kind = described?.kind ?? (await resolveStorageKind(storage, artifactId));
+        const relatedTo = described?.relatedTo ?? (await resolveStorageRelatedTo(storage, artifactId));
         stashPulseVaultContext(req, { artifactId, kind, relatedTo });
         if (!authorize)
             return { kind, relatedTo };
         try {
-            await authorize(req, { phase, artifactId, kind, relatedTo, token });
+            await authorize(req, {
+                phase,
+                artifactId,
+                kind,
+                relatedTo,
+                token,
+                ...describedFields(described),
+            });
             return { kind, relatedTo };
         }
         catch (err) {
@@ -367,6 +515,10 @@ export function createPulseVaultCore(options) {
                 writeJson(res, 501, pulseVaultError('Storage adapter does not support delete'));
                 return;
             }
+            if (await isLocked(artifactId, prepared.relatedTo)) {
+                writeJson(res, 403, pulseVaultError('A finished artifact is locked'));
+                return;
+            }
             const removed = await storage.remove(artifactId);
             if (!removed) {
                 writeJson(res, 404, pulseVaultError('Artifact not found'));
@@ -427,44 +579,205 @@ export function createPulseVaultCore(options) {
             const prepared = await prepareArtifactRequest(req, res, artifactId, 'resolve', token);
             if (!prepared)
                 return;
-            const resolved = await storage.resolve(artifactId);
-            if (!resolved) {
-                writeJson(res, 404, pulseVaultError('Artifact not found'));
-                return;
+            // Twice at most: a conversion can switch the artifact to its new file between the
+            // resolution and the open, and then the second resolution finds the new one.
+            for (let attempt = 0; attempt < 2; attempt++) {
+                const resolved = await storage.resolve(artifactId);
+                if (!resolved)
+                    break;
+                // While a video is being converted its URL serves the original bytes, which the
+                // conversion replaces: revalidate instead of the configured (possibly `immutable`) cache,
+                // so nobody keeps the original once the converted file is in place. Also when this
+                // instance resolved a file other than the one storage now names (another instance
+                // switched it): those bytes are about to go.
+                const meta = completion.converts('video') ? await describe(artifactId) : null;
+                const converting = meta !== null &&
+                    completion.converts(meta.kind) &&
+                    (!meta.converted || (resolved.kind === 'stream' && !resolved.filename.endsWith(meta.ext)));
+                if (await serveResolution(req, res, resolved, converting))
+                    return;
             }
-            if (resolved.kind === 'redirect') {
-                res.writeHead(resolved.statusCode ?? 302, { Location: resolved.url });
-                res.end();
+            writeJson(res, 404, pulseVaultError('Artifact not found'));
+        }
+        catch (err) {
+            failClosed(res, err, 'artifact get');
+        }
+    };
+    /**
+     * Stream or redirect to a resolved artifact — the tail of the GET route, shared with the poster
+     * route. An artifact URL names immutable bytes once finished, so it takes the configured
+     * `cache`; the poster URL is a lookup whose answer changes when a newer thumbnail lands, and a
+     * video still being converted is about to change, so those are revalidated on every request
+     * (`mustRevalidate`). Resolves `false`, having written nothing, when the file opened isn't the
+     * one `send` described (a conversion removed or replaced it in between): the caller resolves
+     * again.
+     */
+    const serveResolution = async (req, res, resolved, mustRevalidate = false) => {
+        if (resolved.kind === 'redirect') {
+            res.writeHead(resolved.statusCode ?? 302, {
+                Location: resolved.url,
+                ...(mustRevalidate ? { 'cache-control': 'no-store' } : {}),
+            });
+            res.end();
+            return true;
+        }
+        const cacheOptions = mustRevalidate
+            ? { cacheControl: true, maxAge: 0, immutable: false }
+            : cache;
+        const result = await send(req, resolved.filename, { root: resolved.root, ...cacheOptions });
+        if (result.type === 'error') {
+            if (result.statusCode === 404)
+                return false;
+            writeJson(res, result.statusCode, pulseVaultError(result.metadata.error.message));
+            return true;
+        }
+        // The file stream opens it after `send` returned: wait for that before the headers go out,
+        // and check it opened the file the headers describe. Once open, the file being replaced or
+        // removed no longer matters to this response.
+        if (await fileChanged(result.stream, result.metadata.stat))
+            return false;
+        const headers = { ...result.headers };
+        // If the storage adapter provided an explicit content type (e.g. for
+        // non-standard extensions like `.pulse`), override what @fastify/send
+        // would otherwise infer from the filename.
+        if (resolved.contentType) {
+            headers['content-type'] = resolved.contentType;
+        }
+        res.writeHead(result.statusCode, headers);
+        // Headers are on the wire now, so a mid-stream read error (file removed
+        // after stat, disk error) can't become a 500 — destroy the socket instead
+        // of letting an unhandled 'error' crash the process. Destroy the source on
+        // client disconnect so the file descriptor is never leaked.
+        result.stream.on('error', (err) => failClosed(res, err, 'artifact stream'));
+        // A client that aborts mid-download makes the *response* stream emit its own
+        // 'error' (ECONNRESET / EPIPE). `.pipe` doesn't forward that, and an unhandled
+        // 'error' on `res` is fatal to the process — so swallow it (the 'close' handler
+        // above already tears down the source and reclaims the fd).
+        res.on('error', () => { });
+        res.on('close', () => result.stream.destroy());
+        result.stream.pipe(res);
+        return true;
+    };
+    /** The declared length and bytes received of an upload, from tus's own record. */
+    const uploadProgress = async (meta) => {
+        try {
+            const upload = await storage.datastore.getUpload(uploadIdOf(meta));
+            return {
+                ...(typeof upload.size === 'number' ? { size: upload.size } : {}),
+                ...(typeof upload.offset === 'number' ? { bytesReceived: upload.offset } : {}),
+            };
+        }
+        catch {
+            return {};
+        }
+    };
+    const getStatus = async (artifactId) => {
+        const meta = isUuid(artifactId) ? await describe(artifactId) : null;
+        if (!meta)
+            return { artifactId, state: 'unknown' };
+        const state = !meta.ready
+            ? 'uploading'
+            : completion.converts(meta.kind) && !meta.converted
+                ? 'processing'
+                : 'ready';
+        return {
+            artifactId,
+            state,
+            kind: meta.kind,
+            ...(meta.relatedTo ? { relatedTo: meta.relatedTo } : {}),
+            ...(meta.name ? { name: meta.name } : {}),
+            ...(await uploadProgress(meta)),
+            acknowledged: meta.acknowledged,
+            ...(meta.webReady ? { webReady: meta.webReady } : {}),
+            ...(meta.outcome !== undefined ? { outcome: meta.outcome } : {}),
+            ...(meta.context !== undefined ? { context: meta.context } : {}),
+        };
+    };
+    const getPulse = async (artifactId) => {
+        const video = isUuid(artifactId) ? await describe(artifactId) : null;
+        const pulse = { video };
+        if (!video || typeof storage.listRelated !== 'function')
+            return pulse;
+        for await (const record of storage.listRelated(artifactId)) {
+            if (!record.ready)
+                continue;
+            const slot = record.kind === 'thumbnail'
+                ? 'thumbnail'
+                : record.kind === 'captions'
+                    ? 'captions'
+                    : record.kind === 'project'
+                        ? 'manifest'
+                        : null;
+            if (!slot)
+                continue;
+            // One per kind: a pulse uploads each once, and a retry that re-sent one is the newer —
+            // by when it finished (`readyAt`), which later bookkeeping never moves.
+            const meta = await describe(record.artifactId);
+            if (!meta)
+                continue;
+            const current = pulse[slot];
+            if (current && (current.readyAt ?? current.updatedAt) >= (meta.readyAt ?? meta.updatedAt))
+                continue;
+            pulse[slot] = meta;
+        }
+        return pulse;
+    };
+    const recordOutcome = async (artifactId, outcome) => {
+        if (typeof storage.patchArtifact !== 'function') {
+            throw new TypeError('recordOutcome needs a storage adapter with `patchArtifact`');
+        }
+        if (!isUuid(artifactId))
+            return false;
+        return storage.patchArtifact(artifactId, { outcome: outcome === undefined ? null : outcome });
+    };
+    /**
+     * `GET /artifacts/:artifactId/status`: where an upload is, for a page waiting on it. Authorized
+     * as `status`, which `createCapabilityAuthorize` grants to the pairing token and to a view token.
+     */
+    const handleStatus = async (req, res, artifactId, token) => {
+        stampProtocolVersion(res);
+        if (rejectOutdatedClient(req, res))
+            return;
+        try {
+            const prepared = await prepareArtifactRequest(req, res, artifactId, 'status', token);
+            if (!prepared)
                 return;
-            }
-            const result = await send(req, resolved.filename, { root: resolved.root, ...cache });
-            if (result.type === 'error') {
-                writeJson(res, result.statusCode, pulseVaultError(result.metadata.error.message));
+            res.setHeader('cache-control', 'no-store');
+            // The token's context is the host's data about the upload, not the viewer's business.
+            const { context: _context, ...status } = await getStatus(artifactId);
+            writeJson(res, 200, status);
+        }
+        catch (err) {
+            failClosed(res, err, 'artifact status');
+        }
+    };
+    /**
+     * `GET /artifacts/:artifactId/poster`: the finished thumbnail `relatedTo` the video, served as
+     * the artifact route would serve it. Authorized as `resolve` on the video, so whoever may watch
+     * it may see its poster. 404 until the poster has landed.
+     */
+    const handlePoster = async (req, res, artifactId, token) => {
+        stampProtocolVersion(res);
+        if (rejectOutdatedClient(req, res))
+            return;
+        try {
+            const prepared = await prepareArtifactRequest(req, res, artifactId, 'resolve', token);
+            if (!prepared)
+                return;
+            const { thumbnail } = await getPulse(artifactId);
+            const resolved = thumbnail ? await storage.resolve(thumbnail.artifactId) : null;
+            if (!resolved) {
+                res.setHeader('cache-control', 'no-store');
+                writeJson(res, 404, pulseVaultError('No poster for this artifact'));
                 return;
             }
-            const headers = { ...result.headers };
-            // If the storage adapter provided an explicit content type (e.g. for
-            // non-standard extensions like `.pulse`), override what @fastify/send
-            // would otherwise infer from the filename.
-            if (resolved.contentType) {
-                headers['content-type'] = resolved.contentType;
+            if (!(await serveResolution(req, res, resolved, true))) {
+                res.setHeader('cache-control', 'no-store');
+                writeJson(res, 404, pulseVaultError('No poster for this artifact'));
             }
-            res.writeHead(result.statusCode, headers);
-            // Headers are on the wire now, so a mid-stream read error (file removed
-            // after stat, disk error) can't become a 500 — destroy the socket instead
-            // of letting an unhandled 'error' crash the process. Destroy the source on
-            // client disconnect so the file descriptor is never leaked.
-            result.stream.on('error', (err) => failClosed(res, err, 'artifact stream'));
-            // A client that aborts mid-download makes the *response* stream emit its own
-            // 'error' (ECONNRESET / EPIPE). `.pipe` doesn't forward that, and an unhandled
-            // 'error' on `res` is fatal to the process — so swallow it (the 'close' handler
-            // above already tears down the source and reclaims the fd).
-            res.on('error', () => { });
-            res.on('close', () => result.stream.destroy());
-            result.stream.pipe(res);
         }
         catch (err) {
-            failClosed(res, err, 'artifact get');
+            failClosed(res, err, 'artifact poster');
         }
     };
     const handler = async (req, res, next) => {
@@ -520,6 +833,16 @@ export function createPulseVaultCore(options) {
             await handleViewLink(req, res, viewLinkMatch[1]);
             return;
         }
+        const statusMatch = pathname.match(/^\/artifacts\/([^/]+)\/status$/);
+        if (statusMatch?.[1] && req.method === 'GET') {
+            await handleStatus(req, res, statusMatch[1], url.searchParams.get('token') ?? undefined);
+            return;
+        }
+        const posterMatch = pathname.match(/^\/artifacts\/([^/]+)\/poster$/);
+        if (posterMatch?.[1] && req.method === 'GET') {
+            await handlePoster(req, res, posterMatch[1], url.searchParams.get('token') ?? undefined);
+            return;
+        }
         const artifactMatch = pathname.match(/^\/artifacts\/([^/]+)$/);
         if (artifactMatch?.[1]) {
             const artifactId = artifactMatch[1];
@@ -538,6 +861,7 @@ export function createPulseVaultCore(options) {
         handler,
         shutdown: async () => {
             await retentionSweep?.stop();
+            await completion.stop();
             await storage.shutdown?.();
         },
         handleTus,
@@ -545,16 +869,26 @@ export function createPulseVaultCore(options) {
         handleArtifactGet,
         handleViewLink,
         handleArtifactDelete,
+        handleStatus,
+        handlePoster,
+        getStatus,
+        getPulse,
+        recordOutcome,
+        replayCompletions: () => completion.replay(),
+        conformAvailable: () => options.webReady
+            ? webReadyAvailable(typeof options.webReady === 'object' ? options.webReady : {})
+            : Promise.resolve(false),
     };
 }
 // Re-exported so a non-Fastify consumer never needs to import from both `.`
 // and `./core` for a normal setup — these are already framework-agnostic
 // and identical to what the `.` (Fastify) entry point re-exports.
 export { createLocalStorage } from './storage/local.js';
+export { uploadIdOf } from './storage/types.js';
 export { createS3Storage } from './storage/s3.js';
-export { sniffMp4, createMp4Sniffer, createS3Mp4Sniffer } from './lib/magic.js';
-export { ensureWebReady, scanMoovPosition } from './lib/web-ready.js';
-export { buildUploadLink } from './lib/deeplinks.js';
+export { sniffMp4, createMp4Sniffer, createS3Mp4Sniffer, sniffVideo, createVideoValidator } from './lib/magic.js';
+export { ensureWebReady, scanMoovPosition, probeVideo, webReadyAvailable, CONFORM_TARGET, CONFORM_VIDEO_EXTENSIONS, } from './lib/web-ready.js';
+export { buildUploadLink, PULSE_OPEN_URL } from './lib/deeplinks.js';
 export { issueCapabilityToken, verifyCapabilityToken, issueViewToken, verifyViewToken, createCapabilityAuthorize, } from './lib/capability-token.js';
 export { createViewLinkIssuer } from './lib/view-links.js';
 export { sweepAbandonedUploads } from './lib/retention.js';