videobook 0.3.0 → 0.3.1

package/dist/media-library.js

@@ -7,9 +7,9 @@ import { markDescendantsStale } from "./notebook-action-catalog.js";
 import { mutateNotebook } from "./notebook-mutations.js";
 import { searchReferenceStore } from "./search-reference-store.js";
 import { comparableHitScore } from "./search-scoring.js";
-import { buildAssetList } from "./tools/reconcile-project-work.js";
+import { projectLibraryAsset, readLibraryCandidates, } from "./library-asset-projection.js";
 import { assetRecency, readAssetUsage, recordAssetUse } from "./asset-usage.js";
-import { matchesTagFilter, tagFacetCounts, transferAssetTags, } from "./asset-tags.js";
+import { tagFacetCounts, transferAssetTags, } from "./asset-tags.js";
 import { addStatusCounts, countBrowseStatuses, emptyStatusCounts, matchesBrowseStatus, pageLibraryAssets, } from "./library-browse.js";
 function isMediaCellType(value) {
     return value === "audio" || value === "image" || value === "video";
@@ -101,9 +101,12 @@ export async function setNotebookMediaSlot(engine, input) {
         revision: result.value.hash,
     };
 }
-function kindMatches(requested, kind) {
-    return requested.has(kind)
-        || (kind === "final" && requested.has("video"));
+function libraryArtifactKinds(requested) {
+    return [
+        ...(requested.has("audio") ? ["audio"] : []),
+        ...(requested.has("image") ? ["image"] : []),
+        ...(requested.has("video") ? ["video", "final"] : []),
+    ];
 }
 function searchRank(asset, query) {
     if (!query)
@@ -143,175 +146,177 @@ function compareRecentlyUsed(left, right) {
         ? created
         : left.artifact_id.localeCompare(right.artifact_id);
 }
-export async function searchLibraryAssets(books, input) {
-    await books.ready();
-    const query = input.query?.trim().toLowerCase() ?? "";
-    const requested = new Set(input.kinds);
-    const prepared = input.referenceId
-        ? searchReferenceStore.get(input.referenceId).reference
-        : undefined;
-    const searching = Boolean(query || prepared);
-    const browseStatus = searching
-        ? "ready"
-        : (input.browseStatus ?? "ready");
-    const artifactKinds = [
-        ...(requested.has("audio") ? ["audio"] : []),
-        ...(requested.has("image") ? ["image"] : []),
-        ...(requested.has("video") ? ["video", "final"] : []),
-    ];
-    const summaries = books.list({ sort: "newest" });
-    const results = await Promise.allSettled(summaries.map(async (summary) => {
-        const book = books.get(summary.bookId);
-        if (!book.ok)
-            throw new Error(book.error.message);
-        const engine = book.value.engine;
-        const builtAssets = await engine.withLocalMedia(() => buildAssetList(engine, summary.bookId, "newest"));
-        const usage = readAssetUsage(engine);
-        const eligible = builtAssets
-            .filter((asset) => kindMatches(requested, asset.type)
-            && matchesTagFilter(asset.tags ?? undefined, input.tags))
-            .map((asset) => ({
-            ...asset,
-            owning_book_id: summary.bookId,
-            owning_book_name: summary.name,
-            last_used_at: lastUsedAt(usage.get(asset.artifact_id)),
-        }));
-        const statusCounts = countBrowseStatuses(eligible);
-        const readyAssets = eligible.filter((asset) => asset.status === "ready");
-        const assets = searching
-            ? readyAssets
-            : eligible.filter((asset) => matchesBrowseStatus(asset.status, browseStatus));
-        let hits = [];
-        let searchError;
-        let preparationJob;
-        if (searching) {
-            registerLocalClipSearchProvider(engine);
-            const searchQuery = {
-                ...(query ? { text: query } : {}),
-                modalities: query
-                    ? ["visual", "metadata"]
-                    : ["visual"],
-                artifactKinds,
-                sourceArtifactIds: readyAssets.map((asset) => asset.artifact_id),
-                limit: 100,
-            };
-            const result = prepared
-                ? await engine.temporalSearch.queryPrepared(searchQuery, prepared, input.referenceRange ? { range: input.referenceRange } : {})
-                : await engine.temporalSearch.query(searchQuery);
-            if (result.ok) {
-                hits = result.value.hits;
-            }
-            else if (result.error.code === "NOT_READY" && result.error.details?.requiresIndexPreparation) {
-                preparationJob = await enqueueTemporalSearchPreparation(summary.bookId);
-            }
-            else {
-                searchError = result.error.message;
-            }
-        }
-        return {
-            assets,
-            statusCounts,
-            hits,
-            searchError,
-            preparationJob,
-            unindexed: missingVisualIndexes(engine, readyAssets).length,
-        };
+function compareNewest(left, right) {
+    const created = Date.parse(right.created_at) - Date.parse(left.created_at);
+    return created !== 0
+        ? created
+        : left.artifact_id.localeCompare(right.artifact_id);
+}
+function entryKey(entry) {
+    return `${entry.owning_book_id}:${entry.artifact_id}`;
+}
+async function querySemanticHits(engine, plan, readyEntries) {
+    registerLocalClipSearchProvider(engine);
+    const searchQuery = {
+        ...(plan.query ? { text: plan.query } : {}),
+        modalities: plan.query
+            ? ["visual", "metadata"]
+            : ["visual"],
+        artifactKinds: plan.searchKinds,
+        sourceArtifactIds: readyEntries.map((entry) => entry.artifact_id),
+        limit: 100,
+    };
+    const result = plan.prepared
+        ? await engine.temporalSearch.queryPrepared(searchQuery, plan.prepared, plan.referenceRange ? { range: plan.referenceRange } : {})
+        : await engine.temporalSearch.query(searchQuery);
+    return result.ok ? { ok: true, value: result.value.hits } : result;
+}
+async function searchBook(books, summary, plan) {
+    const book = books.get(summary.bookId);
+    if (!book.ok)
+        throw new Error(book.error.message);
+    const engine = book.value.engine;
+    const candidates = await engine.withLocalMedia(() => readLibraryCandidates(engine, {
+        kinds: plan.candidateKinds,
+        ...(plan.tags ? { tags: plan.tags } : {}),
     }));
-    const errors = [];
-    const assets = [];
-    let statusCounts = emptyStatusCounts();
-    const semanticHits = [];
-    results.forEach((result, index) => {
-        if (result.status === "fulfilled") {
-            assets.push(...result.value.assets);
-            statusCounts = addStatusCounts(statusCounts, result.value.statusCounts);
-            semanticHits.push(...result.value.hits.map((hit) => ({
-                key: `${summaries[index]?.bookId ?? "unknown"}:${hit.artifactId}`,
-                hit,
-            })));
-            if (result.value.searchError) {
-                errors.push({
-                    book_id: summaries[index]?.bookId ?? "unknown",
-                    message: result.value.searchError,
-                });
-            }
-            return;
-        }
-        const book = summaries[index];
-        errors.push({
-            book_id: book?.bookId ?? "unknown",
-            message: result.reason instanceof Error
-                ? result.reason.message
-                : String(result.reason),
-        });
-    });
-    const metadataRank = new Map(assets
-        .filter((asset) => !prepared && matchesQuery(asset, query))
-        .sort((left, right) => {
-        const rank = searchRank(left, query) - searchRank(right, query);
-        if (rank !== 0)
-            return rank;
-        const created = Date.parse(right.created_at) - Date.parse(left.created_at);
-        return created !== 0
-            ? created
-            : left.artifact_id.localeCompare(right.artifact_id);
-    })
-        .map((asset, index) => [
-        `${asset.owning_book_id}:${asset.artifact_id}`,
-        index + 1,
-    ]));
-    semanticHits.sort((left, right) => comparableHitScore(right.hit) - comparableHitScore(left.hit)
+    const usage = readAssetUsage(engine);
+    const eligible = candidates.map((candidate) => ({
+        ...candidate,
+        owning_book_id: summary.bookId,
+        owning_book_name: summary.name,
+        last_used_at: lastUsedAt(usage.get(candidate.artifact_id)),
+    }));
+    const readyEntries = eligible.filter((entry) => entry.status === "ready");
+    const result = {
+        entries: plan.searching
+            ? readyEntries
+            : eligible.filter((entry) => matchesBrowseStatus(entry.status, plan.browseStatus)),
+        statusCounts: countBrowseStatuses(eligible),
+        hits: [],
+        unindexed: plan.indexCoverage ? missingVisualIndexes(engine, readyEntries).length : 0,
+    };
+    if (!plan.searching)
+        return result;
+    const hits = await querySemanticHits(engine, plan, readyEntries);
+    if (hits.ok)
+        return { ...result, hits: hits.value };
+    if (hits.error.code === "NOT_READY" && hits.error.details?.requiresIndexPreparation) {
+        return { ...result, preparationJob: await enqueueTemporalSearchPreparation(summary.bookId) };
+    }
+    return { ...result, searchError: hits.error.message };
+}
+function rankEntries(entries, semanticHits, plan) {
+    if (!plan.searching) {
+        return [...entries].sort(compareRecentlyUsed).map((entry) => ({ entry, hit: undefined }));
+    }
+    const metadataRank = new Map(entries
+        .filter((entry) => !plan.prepared && matchesQuery(entry, plan.query))
+        .sort((left, right) => searchRank(left, plan.query) - searchRank(right, plan.query)
+        || compareNewest(left, right))
+        .map((entry, index) => [entryKey(entry), index + 1]));
+    const sortedHits = [...semanticHits].sort((left, right) => comparableHitScore(right.hit) - comparableHitScore(left.hit)
         || left.key.localeCompare(right.key));
     const semanticRank = new Map();
     const semanticMatch = new Map();
-    for (const item of semanticHits) {
+    for (const item of sortedHits) {
         if (semanticRank.has(item.key))
             continue;
         semanticRank.set(item.key, semanticRank.size + 1);
         semanticMatch.set(item.key, item.hit);
     }
-    const ranked = assets
-        .flatMap((asset) => {
-        const key = `${asset.owning_book_id}:${asset.artifact_id}`;
+    return entries
+        .flatMap((entry) => {
+        const key = entryKey(entry);
         const metadata = metadataRank.get(key);
         const semantic = semanticRank.get(key);
-        if ((query || prepared) && metadata === undefined && semantic === undefined) {
+        if (metadata === undefined && semantic === undefined)
             return [];
-        }
-        const hit = semanticMatch.get(key);
         return [{
-                asset: hit
-                    ? {
-                        ...asset,
-                        search_match: {
-                            score: comparableHitScore(hit),
-                            location: hit.location,
-                        },
-                    }
-                    : asset,
+                entry,
+                hit: semanticMatch.get(key),
                 score: (metadata === undefined ? 0 : 1 / (60 + metadata))
                     + (semantic === undefined ? 0 : 1 / (60 + semantic)),
             }];
     })
-        .sort((left, right) => {
-        const rank = right.score - left.score;
-        if (rank !== 0)
-            return rank;
-        const created = Date.parse(right.asset.created_at) - Date.parse(left.asset.created_at);
-        return created !== 0
-            ? created
-            : left.asset.artifact_id.localeCompare(right.asset.artifact_id);
-    })
-        .map((item) => item.asset);
-    if (!query && !prepared)
-        ranked.sort(compareRecentlyUsed);
-    const paged = pageLibraryAssets(ranked, {
+        .sort((left, right) => right.score - left.score || compareNewest(left.entry, right.entry))
+        .map(({ entry, hit }) => ({ entry, hit }));
+}
+async function projectLibraryEntry(books, entry, hit) {
+    const book = books.get(entry.owning_book_id);
+    if (!book.ok)
+        throw new Error(book.error.message);
+    const engine = book.value.engine;
+    const row = await engine.withLocalMedia(() => projectLibraryAsset(engine, entry.owning_book_id, entry));
+    return {
+        ...row,
+        owning_book_id: entry.owning_book_id,
+        owning_book_name: entry.owning_book_name,
+        last_used_at: entry.last_used_at,
+        ...(hit
+            ? { search_match: { score: comparableHitScore(hit), location: hit.location } }
+            : {}),
+    };
+}
+function librarySearchPlan(input) {
+    const query = input.query?.trim().toLowerCase() ?? "";
+    const prepared = input.referenceId
+        ? searchReferenceStore.get(input.referenceId).reference
+        : undefined;
+    const searching = Boolean(query || prepared);
+    const searchKinds = libraryArtifactKinds(new Set(input.kinds));
+    return {
+        query,
+        prepared,
+        referenceRange: input.referenceRange,
+        searching,
+        browseStatus: searching ? "ready" : (input.browseStatus ?? "ready"),
+        candidateKinds: new Set(searchKinds),
+        searchKinds,
+        tags: input.tags,
+        indexCoverage: input.indexCoverage ?? searching,
+    };
+}
+export async function searchLibraryAssets(books, input) {
+    await books.ready();
+    const plan = librarySearchPlan(input);
+    const summaries = books.list({ sort: "newest" });
+    const results = await Promise.allSettled(summaries.map((summary) => searchBook(books, summary, plan)));
+    const errors = [];
+    const entries = [];
+    let statusCounts = emptyStatusCounts();
+    const semanticHits = [];
+    results.forEach((result, index) => {
+        const bookId = summaries[index]?.bookId ?? "unknown";
+        if (result.status === "rejected") {
+            errors.push({
+                book_id: bookId,
+                message: result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason),
+            });
+            return;
+        }
+        entries.push(...result.value.entries);
+        statusCounts = addStatusCounts(statusCounts, result.value.statusCounts);
+        semanticHits.push(...result.value.hits.map((hit) => ({
+            key: `${bookId}:${hit.artifactId}`,
+            hit,
+        })));
+        if (result.value.searchError) {
+            errors.push({ book_id: bookId, message: result.value.searchError });
+        }
+    });
+    const ranked = rankEntries(entries, semanticHits, plan);
+    const paged = pageLibraryAssets(ranked.map(({ entry }) => entry), {
         offset: input.offset ?? 0,
         limit: input.limit ?? 50,
     });
+    const offset = input.offset ?? 0;
+    const pageHits = ranked.slice(offset, offset + paged.pageAssets.length);
     return {
-        assets: paged.pageAssets,
-        tag_facets: tagFacetCounts(ranked),
+        assets: await Promise.all(pageHits.map(({ entry, hit }) => projectLibraryEntry(books, entry, hit))),
+        tag_facets: tagFacetCounts(paged.matching),
         unindexed_visual_assets: results.reduce((count, result) => count + (result.status === "fulfilled" ? result.value.unindexed : 0), 0),
         preparationJobs: results.flatMap((result) => result.status === "fulfilled" && result.value.preparationJob
             ? [result.value.preparationJob]

package/dist/notebook-sticky-settings.js

@@ -0,0 +1,60 @@
+import { tryResolveModel } from "./media/descriptor.js";
+import { parseStickySettings, stickySettingGroup, stickySettingsFor, stickySettingsFrom, takesDuration, } from "./media/preferred-defaults.js";
+import { controlsForModel } from "./notebook-generation-controls.js";
+function settingsKey(notebookId) {
+    return `notebook-generation-settings:${notebookId}`;
+}
+function generationSettingsOf(cell) {
+    const settings = cell?.inputs?.generationSettings;
+    return settings && typeof settings === "object" && !Array.isArray(settings)
+        ? settings
+        : {};
+}
+function changedSettings(previous, next) {
+    return Object.fromEntries(Object.entries(next).filter(([name, value]) => previous[name] !== value));
+}
+export function readNotebookStickySettings(engine, notebookId) {
+    const stored = engine.settings.get(settingsKey(notebookId));
+    return stored ? parseStickySettings(stored) : {};
+}
+export function rememberNotebookStickySettings(engine, notebookId, next, previous) {
+    const changed = stickySettingsFrom(changedSettings(generationSettingsOf(previous), generationSettingsOf(next)));
+    if (Object.keys(changed).length === 0)
+        return;
+    const written = engine.settings.set(settingsKey(notebookId), {
+        ...readNotebookStickySettings(engine, notebookId),
+        ...changed,
+    });
+    if (!written.ok)
+        throw new Error(written.error.message);
+}
+function stickyControlsFor(model) {
+    const resolved = tryResolveModel(model);
+    if (!resolved)
+        return [];
+    const timed = takesDuration(resolved.entry);
+    return controlsForModel(resolved).flatMap((control) => {
+        const group = stickySettingGroup(control.name);
+        if (!group || (group === "duration" && !timed))
+            return [];
+        return [{
+                name: control.name,
+                valueType: control.valueType,
+                options: control.options ?? [],
+                ...(control.minimum === undefined ? {} : { minimum: control.minimum }),
+                ...(control.maximum === undefined ? {} : { maximum: control.maximum }),
+            }];
+    });
+}
+export function seedNotebookStickySettings(cell, sticky) {
+    if (!cell.model || Object.keys(sticky).length === 0)
+        return cell;
+    const explicit = generationSettingsOf(cell);
+    const seeded = stickySettingsFor(stickyControlsFor(cell.model).filter((control) => explicit[control.name] === undefined), sticky);
+    if (Object.keys(seeded).length === 0)
+        return cell;
+    return {
+        ...cell,
+        inputs: { ...(cell.inputs ?? {}), generationSettings: { ...seeded, ...explicit } },
+    };
+}