videobook 0.3.0 → 0.3.2

package/dist/media/preferred-defaults.js

@@ -0,0 +1,161 @@
+const PREFERRED_DURATION_SECONDS = 12;
+const PREFERRED_ASPECT_RATIO = "9:16";
+const PREFERRED_IMAGE_SIZE_PRESET = "portrait_16_9";
+const IMAGE_SIZE_PRESETS = new Set(["square_hd", "square", "portrait_4_3", "portrait_16_9", "landscape_4_3", "landscape_16_9"]);
+const GROUP_FIELDS = {
+    duration: ["duration"],
+    aspect: ["aspect_ratio", "aspectRatio", "image_size"],
+    resolution: ["resolution", "output_resolution", "size", "mode"],
+    quality: ["quality"],
+    bitrate: ["bitrate_mode"],
+};
+const QUALITY_RANK = ["very_low", "low", "basic", "standard", "medium", "high"];
+const UNTIMED_VIDEO_OPERATIONS = new Set(["edit_video", "lip_sync", "upscale_video", "motion_control"]);
+export function stickySettingGroup(name) {
+    const entry = Object.entries(GROUP_FIELDS).find(([, fields]) => fields.includes(name));
+    return entry ? entry[0] : null;
+}
+function resolutionRank(value) {
+    if (typeof value === "number")
+        return value;
+    const match = /^(\d+(?:\.\d+)?)\s*(p|k|sq)?$/iu.exec(value.trim());
+    if (!match)
+        return null;
+    const amount = Number(match[1]);
+    return match[2]?.toLowerCase() === "k" ? amount * 1000 : amount;
+}
+function isResolutionEnum(values) {
+    return values.length > 0 && values.every((value) => resolutionRank(value) !== null);
+}
+function highestBy(values, rank) {
+    const ranked = values.flatMap((value) => {
+        const score = rank(value);
+        return score === null ? [] : [{ value, score }];
+    });
+    if (ranked.length === 0)
+        return undefined;
+    return ranked.reduce((best, candidate) => candidate.score > best.score ? candidate : best).value;
+}
+function qualityRank(value) {
+    const index = QUALITY_RANK.indexOf(String(value).toLowerCase());
+    return index < 0 ? null : index;
+}
+function isNumeric(option) {
+    return option.valueType === "number" || option.valueType === "integer" || option.valueType === "json";
+}
+function clampToBounds(option, value) {
+    const low = option.minimum ?? Number.NEGATIVE_INFINITY;
+    const high = option.maximum ?? Number.POSITIVE_INFINITY;
+    return Math.min(Math.max(value, low), high);
+}
+function nearestDurationChoice(values, target) {
+    const numeric = values.filter((value) => Number.isFinite(Number(value)));
+    if (numeric.length === 0)
+        return undefined;
+    const atOrBelow = numeric.filter((value) => Number(value) <= target);
+    const pool = atOrBelow.length > 0 ? atOrBelow : numeric;
+    return pool.reduce((best, candidate) => Math.abs(Number(candidate) - target) < Math.abs(Number(best) - target) ? candidate : best);
+}
+function preferredDuration(option) {
+    if (option.enumValues.length > 0)
+        return nearestDurationChoice(option.enumValues, PREFERRED_DURATION_SECONDS);
+    if (!isNumeric(option))
+        return undefined;
+    return clampToBounds(option, PREFERRED_DURATION_SECONDS);
+}
+function takesImageSizePreset(entry, option) {
+    if (option.name !== "image_size" || option.valueType !== "json" || !entry.id.startsWith("fal:"))
+        return false;
+    if (!entry.operations.includes("text_to_image"))
+        return false;
+    return option.defaultValue === undefined || IMAGE_SIZE_PRESETS.has(String(option.defaultValue));
+}
+function preferredAspect(entry, option) {
+    if (option.enumValues.includes(PREFERRED_ASPECT_RATIO))
+        return PREFERRED_ASPECT_RATIO;
+    return takesImageSizePreset(entry, option) ? PREFERRED_IMAGE_SIZE_PRESET : undefined;
+}
+function preferredResolution(option) {
+    if (!isResolutionEnum(option.enumValues.filter((value) => value !== "auto")))
+        return undefined;
+    return highestBy(option.enumValues, resolutionRank);
+}
+function preferredQuality(option) {
+    return highestBy(option.enumValues, qualityRank);
+}
+export function takesDuration(entry) {
+    return entry.media === "video" && entry.operations.some((operation) => !UNTIMED_VIDEO_OPERATIONS.has(operation));
+}
+function preferredValue(entry, option) {
+    if (option.name !== option.path || entry.pinnedDefaults?.includes(option.name))
+        return undefined;
+    const group = stickySettingGroup(option.name);
+    if (group === "duration")
+        return takesDuration(entry) ? preferredDuration(option) : undefined;
+    if (group === "aspect")
+        return preferredAspect(entry, option);
+    if (group === "resolution")
+        return preferredResolution(option);
+    if (group === "quality" || group === "bitrate")
+        return preferredQuality(option);
+    return undefined;
+}
+export function preferredDefaults(entry, options) {
+    if (entry.media !== "video" && entry.media !== "image")
+        return {};
+    return Object.fromEntries(options.flatMap((option) => {
+        const value = preferredValue(entry, option);
+        return value === undefined ? [] : [[option.name, value]];
+    }));
+}
+function sameResolution(left, right) {
+    const a = resolutionRank(left);
+    const b = resolutionRank(right);
+    return a !== null && a === b && String(left).toLowerCase().replace(/p$/u, "") === String(right).toLowerCase().replace(/p$/u, "");
+}
+function matchingChoice(choices, value) {
+    return choices.find((choice) => choice === value)
+        ?? choices.find((choice) => String(choice).toLowerCase() === String(value).toLowerCase())
+        ?? choices.find((choice) => typeof choice !== "boolean" && typeof value !== "boolean" && sameResolution(choice, value));
+}
+function acceptedStickyValue(control, value) {
+    if (control.options.length > 0)
+        return matchingChoice(control.options, value);
+    if (control.valueType !== "number")
+        return undefined;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric))
+        return undefined;
+    if (control.minimum !== undefined && numeric < control.minimum)
+        return undefined;
+    if (control.maximum !== undefined && numeric > control.maximum)
+        return undefined;
+    return numeric;
+}
+function isStickyValue(group, value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return false;
+    return group !== "resolution" || resolutionRank(value) !== null;
+}
+export function stickySettingsFrom(settings) {
+    return Object.fromEntries(Object.entries(settings).flatMap(([name, value]) => {
+        const group = stickySettingGroup(name);
+        if (!group || !isStickyValue(group, value))
+            return [];
+        return [[group, value]];
+    }));
+}
+function isStickySettingGroup(name) {
+    return Object.hasOwn(GROUP_FIELDS, name);
+}
+export function parseStickySettings(stored) {
+    return Object.fromEntries(Object.entries(stored).flatMap(([group, value]) => isStickySettingGroup(group) && isStickyValue(group, value) ? [[group, value]] : []));
+}
+export function stickySettingsFor(controls, sticky) {
+    return Object.fromEntries(controls.flatMap((control) => {
+        const group = stickySettingGroup(control.name);
+        const remembered = group ? sticky[group] : undefined;
+        const value = remembered === undefined ? undefined : acceptedStickyValue(control, remembered);
+        return value === undefined ? [] : [[control.name, value]];
+    }));
+}

package/dist/media/prompt-dialects.js

@@ -1,4 +1,4 @@
-import { replaceHappyHorseAssetMentions, replaceNaturalAssetMentions, rewriteImageRefMentionsToBrackets, rewriteSeedanceAssetMentions, rewriteViduReferenceMentions, stripRefMentions, } from "../generation-reference-mentions.js";
+import { replaceHappyHorseAssetMentions, replaceNaturalAssetMentions, rewriteImageRefMentionsToBrackets, rewriteKling4FrameMentions, rewriteKling4ReferenceMentions, rewriteSeedanceAssetMentions, rewriteViduReferenceMentions, stripRefMentions, } from "../generation-reference-mentions.js";
 const SLOT_TOKEN = /@((image|video|audio)(\d+)|firstframe|lastframe)(?![\w-])/giu;
 function refsFor(refs, role) {
     return (refs[role] ?? []).filter((ref) => !/^https?:\/\//u.test(ref));
@@ -58,6 +58,14 @@ function rewrite(dialect, prompt, refs) {
             return rewriteImageRefMentionsToBrackets(prompt, refsFor(refs, "image"));
         case "vidu":
             return rewriteViduReferenceMentions(prompt, refsFor(refs, "image"), refsFor(refs, "audio"));
+        case "kling4":
+            return rewriteKling4ReferenceMentions(prompt, refsFor(refs, "image"), refsFor(refs, "video"));
+        case "kling4_keyframes":
+            return rewriteKling4FrameMentions(prompt, {
+                first: refsFor(refs, "first_frame"),
+                keyframes: refsFor(refs, "image"),
+                last: refsFor(refs, "last_frame"),
+            });
         case "happyhorse_edit":
             return replaceHappyHorseAssetMentions(prompt, refsFor(refs, "video")[0] ?? null, refsFor(refs, "image"));
     }

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 } },
+    };
+}