@m0saic/templates 0.2.0

package/dist/m0saic/media/trickplay/v1/trickplay.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Trickplay sheet generator — `@m0saic/media/trickplay/v1`.
+ *
+ * Renders the seek-preview artifacts video players use while scrubbing:
+ * sprite sheets of video thumbnails at a fixed interval, placed at
+ * known row-major grid coordinates, plus the player-consumable index
+ * files (WebVTT storyboard with `#xywh` cues; JSON manifest carrying
+ * Jellyfin-compatible fields and DASH-IF `thumbnail_tile` grid info).
+ *
+ * One template covers every output shape via the `outputFormat` knob
+ * (watermark's per-step-format precedent): `png` (default) / `jpeg`
+ * emit static sheets + index sidecars; `mp4` emits an animated
+ * contact-sheet preview (no sidecars). `outputHints` deliberately
+ * carries NO `format` — a template-level container hint would override
+ * the user's `-o` extension in `resolveOutputFormat`; each pipeline
+ * step declares its own format instead.
+ *
+ * Always returns an `emit:"multi"` pipeline (watermark precedent):
+ * per-step canvases are the only vehicle for probed-dims sheet sizing,
+ * and long inputs fan out to multiple sheet steps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trickplay = void 0;
+exports.resolveTrickplayKnobs = resolveTrickplayKnobs;
+const types_1 = require("@m0saic/types");
+const template_utils_1 = require("@m0saic/template-utils");
+const pipeline_1 = require("./pipeline");
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    sourceIds: {
+        type: "media[]",
+        required: true,
+        description: "Video(s) to index — pick a folder, one or more files, or drag-and-drop. One trickplay sheet set (sheets + WebVTT + manifest) per input.",
+        meta: {
+            ui: { label: "Source(s)", order: 1 },
+            control: { multiple: true, picker: "folder", accept: ["video"] },
+        },
+    },
+    intervalSec: {
+        type: "number",
+        required: false,
+        description: "Seconds between thumbnails.",
+        meta: { constraints: { min: 1, max: 600 }, ui: { label: "Interval (s)", order: 1 } },
+    },
+    tileWidth: {
+        type: "number",
+        required: false,
+        description: "Thumbnail width in pixels (height derives from the source aspect; both even-rounded).",
+        meta: { constraints: { min: 64, max: 1024 }, ui: { label: "Tile width (px)", order: 2 } },
+    },
+    cols: {
+        type: "number",
+        required: false,
+        description: "Thumbnails per sheet row.",
+        meta: { constraints: { min: 1, max: 20 }, ui: { label: "Columns", order: 3 } },
+    },
+    rowsPerSheet: {
+        type: "number",
+        required: false,
+        description: "Maximum thumbnail rows per sheet — longer content spills to additional sheets.",
+        meta: { constraints: { min: 1, max: 20 }, ui: { label: "Rows per sheet", order: 4 } },
+    },
+    outputFormat: {
+        type: "string",
+        required: false,
+        description: 'Sheet output format. "png"/"jpeg" render static sheets with WebVTT + JSON manifest sidecars; "mp4" renders an animated contact-sheet preview (no sidecars).',
+        meta: {
+            constraints: { oneOf: ["png", "jpeg", "mp4"] },
+            ui: { label: "Output", order: 1 },
+        },
+    },
+});
+const DEFAULTS = {
+    intervalSec: 10,
+    tileWidth: 320,
+    cols: 10,
+    rowsPerSheet: 10,
+    outputFormat: "png",
+};
+const clamp = (v, min, max) => Math.min(max, Math.max(min, v));
+/** Resolve + clamp props to deterministic step knobs. */
+function resolveTrickplayKnobs(props) {
+    var _a, _b, _c, _d;
+    const outputFormat = props.outputFormat === "jpeg" || props.outputFormat === "mp4"
+        ? props.outputFormat
+        : "png";
+    return {
+        intervalSec: clamp((_a = props.intervalSec) !== null && _a !== void 0 ? _a : DEFAULTS.intervalSec, 1, 600),
+        tileWidth: clamp((_b = props.tileWidth) !== null && _b !== void 0 ? _b : DEFAULTS.tileWidth, 64, 1024),
+        cols: clamp(Math.round((_c = props.cols) !== null && _c !== void 0 ? _c : DEFAULTS.cols), 1, 20),
+        rowsPerSheet: clamp(Math.round((_d = props.rowsPerSheet) !== null && _d !== void 0 ? _d : DEFAULTS.rowsPerSheet), 1, 20),
+        outputFormat,
+    };
+}
+exports.Trickplay = {
+    id: (0, types_1.asTemplateId)("@m0saic/media/trickplay/v1"),
+    label: "Trickplay Sheets",
+    description: "Generate the seek-preview thumbnails video players use while scrubbing: sprite sheets at a fixed interval with a WebVTT storyboard and a Jellyfin/DASH-compatible JSON manifest. Batch a folder for one sheet set per video.",
+    version: 1,
+    capabilities: { tier: "core" },
+    tags: ["media", "trickplay", "storyboard", "batch", "developers", "creators", "video-player", "sprite", "streaming"],
+    // No `format` hint on purpose (see file header): steps declare their own.
+    outputHints: {
+        format: { kind: "image", container: "png" },
+        width: 1920,
+        height: 1080,
+        fps: 30,
+        durationMs: 5000,
+    },
+    propsSchema,
+    defaultProps: { ...DEFAULTS },
+    async render(props, ctx) {
+        const inputs = props.sourceIds && props.sourceIds.length > 0 ? props.sourceIds : [];
+        if (inputs.length === 0) {
+            return (0, template_utils_1.makeErrorMosaic)('Missing required "Source(s)": pick a folder, one or more video files, or drag-and-drop.', { title: "Trickplay", width: ctx.target.width, height: ctx.target.height });
+        }
+        const knobs = resolveTrickplayKnobs(props);
+        const stepNames = (0, template_utils_1.buildStepNames)(inputs);
+        const steps = inputs.flatMap((inputPath, i) => (0, pipeline_1.buildTrickplayStepsForInput)({ inputPath, stepBaseName: stepNames[i], knobs, ctx }));
+        return { kind: "mosaic_pipeline", version: 1, emit: "multi", steps };
+    },
+};
+(0, template_utils_1.registerTemplate)(exports.Trickplay);

package/dist/m0saic/media/video_to_png_sequence/index.d.ts

@@ -0,0 +1 @@
+export { FrameStripper, type FrameStripperProps } from "./v1";

package/dist/m0saic/media/video_to_png_sequence/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameStripper = void 0;
+var v1_1 = require("./v1");
+Object.defineProperty(exports, "FrameStripper", { enumerable: true, get: function () { return v1_1.FrameStripper; } });

package/dist/m0saic/media/video_to_png_sequence/v1/index.d.ts

@@ -0,0 +1 @@
+export { FrameStripper, type FrameStripperProps } from "./video-to-png-sequence";

package/dist/m0saic/media/video_to_png_sequence/v1/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameStripper = void 0;
+var video_to_png_sequence_1 = require("./video-to-png-sequence");
+Object.defineProperty(exports, "FrameStripper", { enumerable: true, get: function () { return video_to_png_sequence_1.FrameStripper; } });

package/dist/m0saic/media/video_to_png_sequence/v1/video-to-png-sequence.d.ts

@@ -0,0 +1,37 @@
+import type { MosaicTemplate } from "@m0saic/types";
+export type FrameStripperProps = {
+    /**
+     * The source video(s) — THE source knob. Every frame of every input is
+     * emitted as its own PNG step, with step names prefixed by a per-input
+     * slug so files from different videos don't collide on disk. One input
+     * renders a single sequence; multiple fan out via `emit: "multi"`.
+     */
+    sourceIds?: string[];
+    /**
+     * Source-relative milliseconds at which the rendered segment begins.
+     * When set with `clipEndMs`, the template only extracts frames in the
+     * [clipStartMs, clipEndMs] window — the in-UI "scrub to the section
+     * you care about" flow. Unset (or 0) → extract from the start.
+     * Ignored when greater than the input's natural duration.
+     *
+     * Applies uniformly to every input under `sourceIds`. The Make page's
+     * section editor scrubs the first input only (multi-input flows are
+     * drag-drop and rarely need a range).
+     */
+    clipStartMs?: number;
+    /**
+     * Source-relative milliseconds at which the rendered segment ends.
+     * Must be greater than `clipStartMs` when both are set. Unset → run
+     * to the end of the clip. Clamped to the input's duration.
+     */
+    clipEndMs?: number;
+    /**
+     * Cap on the number of frames extracted **per input**. Useful as a
+     * safety net for long inputs (a 60s @ 30fps video → 1800 ffmpeg
+     * invocations). Unset = no cap, every frame of every input (within
+     * the configured clip range, if any) is emitted.
+     */
+    maxFrames?: number;
+};
+export declare const FrameStripper: MosaicTemplate<FrameStripperProps>;
+export default FrameStripper;

package/dist/m0saic/media/video_to_png_sequence/v1/video-to-png-sequence.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameStripper = void 0;
+const types_1 = require("@m0saic/types");
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    // The one source input. One required "Source(s)" field that takes a
+    // folder, one or many files, or drag-and-drop. Every frame of every video
+    // is emitted as its own PNG (emit:multi when >1 input).
+    sourceIds: {
+        type: "media[]",
+        required: true,
+        description: "Source video(s) to strip into PNG sequences — pick a folder, one or more files, or drag-and-drop. Every frame becomes its own PNG.",
+        meta: {
+            ui: { label: "Source(s)" },
+            control: { multiple: true, picker: "folder", accept: ["video"] },
+        },
+    },
+    clipStartMs: {
+        type: "number",
+        required: false,
+        description: "Source-relative ms where the extracted segment starts. Paired with clipEndMs to scrub out a section. Unset → start at 0.",
+        meta: {
+            constraints: { min: 0 },
+            control: {
+                picker: "time-range",
+                videoFromProp: "sourceIds",
+                unit: "ms",
+            },
+            ui: { label: "Clip start" },
+        },
+    },
+    clipEndMs: {
+        type: "number",
+        required: false,
+        description: "Source-relative ms where the extracted segment ends. Must be > clipStartMs when both are set. Unset → run to the end of the clip.",
+        meta: {
+            constraints: { min: 0 },
+            control: {
+                placeholder: "video end",
+                picker: "time-range",
+                videoFromProp: "sourceIds",
+                unit: "ms",
+            },
+            ui: { label: "Clip end" },
+        },
+    },
+    maxFrames: {
+        type: "number",
+        required: false,
+        description: "Cap on the number of frames extracted per input. Each frame is a separate ffmpeg invocation — long inputs are slow. Defaults to no cap.",
+        meta: {
+            control: { placeholder: "all frames" },
+            constraints: { min: 1, max: 100000 },
+            ui: { label: "Max Frames (per input)" },
+        },
+    },
+});
+/**
+ * Resolve the input list from `sourceIds`. Returns `[]` when it's
+ * empty/unset so the caller can surface a fail-fast error.
+ */
+function resolveInputs(props) {
+    if (props.sourceIds && props.sourceIds.length > 0)
+        return props.sourceIds;
+    return [];
+}
+/**
+ * Build unique, filename-safe slugs from input paths.
+ *
+ * Two distinct files can share a basename (`a/clip.mp4`, `b/clip.mp4`).
+ * Dedupe by appending `_2`, `_3`, … so each input's frames carry a
+ * unique step-name prefix (the engine rejects duplicate step names with
+ * `PIPELINE_STEP_NAME_DUPLICATE`). Mirrors the convention in
+ * `screencap-grid`.
+ */
+function buildInputSlugs(inputs) {
+    const used = new Set();
+    const out = [];
+    for (const input of inputs) {
+        const base = (0, template_utils_1.slugifyAssetKeyFromPath)(input);
+        let name = base;
+        let i = 2;
+        while (used.has(name)) {
+            name = `${base}_${i}`;
+            i++;
+        }
+        used.add(name);
+        out.push(name);
+    }
+    return out;
+}
+function frameStepName(inputSlug, frameIndex, totalFrames) {
+    const width = Math.max(4, String(totalFrames).length);
+    return `${inputSlug}_frame_${String(frameIndex + 1).padStart(width, "0")}`;
+}
+// For a frame-stripper the INPUT video is the source of truth: we want
+// every frame at its native rate across its full natural duration. The
+// probed `meta` therefore wins over `ctx.target` (whose duration/fps
+// describe the editor canvas / output timeline, and default to a short
+// 5s / 30fps when the wrapping doc doesn't pin them). Preferring ctx
+// here silently truncated long inputs to the first ~5s.
+function resolveFps(meta, ctxFps) {
+    var _a, _b;
+    return (_b = (_a = meta === null || meta === void 0 ? void 0 : meta.fps) !== null && _a !== void 0 ? _a : ctxFps) !== null && _b !== void 0 ? _b : 30;
+}
+function resolveDurationMs(meta, ctxDurationMs) {
+    var _a, _b;
+    return (_b = (_a = meta === null || meta === void 0 ? void 0 : meta.durationMs) !== null && _a !== void 0 ? _a : ctxDurationMs) !== null && _b !== void 0 ? _b : 1000;
+}
+function resolveCanvas(meta, ctxWidth, ctxHeight) {
+    const w = (meta === null || meta === void 0 ? void 0 : meta.width) != null && meta.width > 0 ? meta.width : ctxWidth;
+    const h = (meta === null || meta === void 0 ? void 0 : meta.height) != null && meta.height > 0 ? meta.height : ctxHeight;
+    return { width: w, height: h };
+}
+// ---- TEMPLATE ----
+exports.FrameStripper = {
+    id: (0, types_1.asTemplateId)("@m0saic/media/video_to_png_sequence/v1"),
+    label: "Frame Stripper",
+    description: "Drop one or more videos, get every frame as a separate numbered PNG. Multi-input renders prefix each frame with the source basename so files don't collide. One ffmpeg invocation per frame — use maxFrames to cap long inputs.",
+    version: 1,
+    capabilities: { tier: "core" },
+    tags: ["media", "frames", "png-sequence", "extract", "developers", "creators", "video"],
+    propsSchema,
+    outputHints: {
+        format: { kind: "image", container: "png" },
+        note: "Outputs N numbered PNGs per input via emit:multi.",
+    },
+    defaultProps: { clipStartMs: 0 },
+    async render(props, ctx) {
+        var _a, _b;
+        const inputs = resolveInputs(props);
+        if (inputs.length === 0) {
+            return (0, template_utils_1.makeErrorMosaic)("Drop one or more videos onto Frame Stripper to extract their frames.", {
+                title: "Frame Stripper",
+                width: ctx.target.width,
+                height: ctx.target.height,
+            });
+        }
+        // Validate the optional clip range up-front. Apply uniformly to every
+        // input (multi-input drag-drop renders simply ignore the range when
+        // unset; the Make page wires both knobs against the first input).
+        if (props.clipStartMs != null &&
+            props.clipEndMs != null &&
+            props.clipEndMs <= props.clipStartMs) {
+            return (0, template_utils_1.makeErrorMosaic)(`Clip end (${props.clipEndMs}ms) must be greater than clip start (${props.clipStartMs}ms).`, {
+                title: "Frame Stripper",
+                width: ctx.target.width,
+                height: ctx.target.height,
+            });
+        }
+        const slugs = buildInputSlugs(inputs);
+        const steps = [];
+        for (let inputIdx = 0; inputIdx < inputs.length; inputIdx++) {
+            const rawPath = inputs[inputIdx];
+            const inputSlug = slugs[inputIdx];
+            const ctxMediaKey = (0, types_1.asAssetId)(rawPath);
+            const sourceAssetId = (0, types_1.asAssetId)((0, template_utils_1.slugifyAssetKeyFromPath)(rawPath));
+            const meta = ctx.media[ctxMediaKey];
+            const fps = resolveFps(meta, ctx.target.fps);
+            const totalDurationMs = resolveDurationMs(meta, ctx.target.durationMs);
+            const { width: stepWidth, height: stepHeight } = resolveCanvas(meta, ctx.target.width, ctx.target.height);
+            // Resolve the effective clip window. Clamped to [0, totalDurationMs]
+            // so out-of-range values degrade gracefully (e.g. a range set in the
+            // UI for a long clip still works when reused against a shorter one).
+            const clipStartMs = Math.max(0, Math.min((_a = props.clipStartMs) !== null && _a !== void 0 ? _a : 0, totalDurationMs));
+            const clipEndMs = Math.max(clipStartMs, Math.min((_b = props.clipEndMs) !== null && _b !== void 0 ? _b : totalDurationMs, totalDurationMs));
+            const segmentDurationMs = clipEndMs - clipStartMs;
+            const { count: frameCount, frameDurationMs } = (0, template_utils_1.computeFrameCount)({
+                durationMs: segmentDurationMs,
+                fps,
+                ...(props.maxFrames != null ? { maxFrames: props.maxFrames } : {}),
+            });
+            // Each step is hermetic: it carries its own assets manifest so the
+            // engine can render it standalone. Sharing one manifest object across
+            // steps would couple their lifetimes; keep them independent.
+            const assets = {
+                [sourceAssetId]: {
+                    kind: "file",
+                    path: rawPath,
+                    mediaType: "video",
+                },
+            };
+            for (let frameIdx = 0; frameIdx < frameCount; frameIdx++) {
+                // Offset by the segment start so the UI's section editor scrubs to
+                // the right slice. Single-input drag-drop renders pass clipStartMs=0
+                // and this is a no-op.
+                const frameClipStartMs = clipStartMs + Math.round(frameIdx * frameDurationMs);
+                const stepName = frameStepName(inputSlug, frameIdx, frameCount);
+                const sources = [
+                    {
+                        type: "media",
+                        mediaType: "video",
+                        assetId: sourceAssetId,
+                        placement: { fit: "cover" },
+                        playback: {
+                            clipStartMs: frameClipStartMs,
+                            clipDurationMs: Math.ceil(frameDurationMs),
+                            loopMode: "freeze",
+                        },
+                        audio: { enabled: false },
+                        editor: { owner: "template" },
+                    },
+                ];
+                const stepDoc = {
+                    kind: "mosaic_document",
+                    version: 1,
+                    sources,
+                    assets,
+                    m0: (0, dsl_stdlib_1.toM0String)("F", "FrameStripper"),
+                    fps,
+                    durationMs: Math.ceil(frameDurationMs),
+                    size: { width: stepWidth, height: stepHeight },
+                    format: { kind: "image", container: "png" },
+                };
+                steps.push({
+                    name: stepName,
+                    label: stepName,
+                    durationMs: Math.ceil(frameDurationMs),
+                    file: stepDoc,
+                });
+            }
+        }
+        return {
+            kind: "mosaic_pipeline",
+            version: 1,
+            emit: "multi",
+            steps,
+        };
+    },
+};
+(0, template_utils_1.registerTemplate)(exports.FrameStripper);
+exports.default = exports.FrameStripper;

package/dist/m0saic/media/watermark/index.d.ts

@@ -0,0 +1 @@
+export * from "./v1";

package/dist/m0saic/media/watermark/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./v1"), exports);

package/dist/m0saic/media/watermark/v1/adaptive.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Adaptive-mode layer assembly: which artwork variant(s) the stamp
+ * shows, and the alpha expression that drives each.
+ *
+ * Variant vocabulary (cohesion mapping, same as the QR stamp):
+ *   - "light" artwork = made FOR bright regions → `image` + `textColorOnLight`
+ *   - primary artwork = made FOR dark regions  → `imageDark ?? image` + `textColor`
+ *     (the user's explicitly-chosen styling — white text by default)
+ *
+ * Degradation rule: `variant: "auto"` needs luma evidence. With no
+ * probe data (host prep skipped / unavailable), auto degrades to
+ * "single" — the user's explicit styling with no evidence-free flip.
+ * (This intentionally differs from `buildAdaptiveAlphaExpr`'s
+ * empty-buckets behavior, which would pin the LIGHT variant on.)
+ *
+ * Pure math — no IO, no engine types beyond LuminanceBucket.
+ */
+import type { LuminanceBucket, MosaicColor, MosaicEngineContext } from "@m0saic/types";
+import type { WatermarkV1Props } from "./watermark";
+/** One appearance slot for windowed mode — the watermark artwork is
+ *  static, so the slot width is a taste constant, not a clip length. */
+export declare const WATERMARK_SLOT_MS = 4000;
+/** Crossfade band for always-on adaptive (same as the QR stamp v1). */
+export declare const ADAPTIVE_LOW_LUMA = 100;
+export declare const ADAPTIVE_HIGH_LUMA = 156;
+/** Per-input luma probe result (pulled via `ctx.analysis`, or injected via the `lumaByInput` prop override). */
+export type WatermarkLumaEntry = {
+    buckets: LuminanceBucket[];
+    overallAvgLuma: number;
+    durationMs: number;
+};
+/**
+ * Pull the per-input region-luminance analysis through `ctx.analysis`
+ * (the engine-mediated on-demand probe). Undefined when the host
+ * attached no analysis surface (design mode, no toolchain) or every
+ * probe failed — adaptive `auto` then degrades to single-variant.
+ * Per-input failures drop that input's entry; a probe must never kill
+ * a render.
+ */
+export declare function probeLumaByInput(props: WatermarkV1Props, inputs: string[], ctx: Pick<MosaicEngineContext, "media" | "analysis">): Promise<Record<string, WatermarkLumaEntry> | undefined>;
+/** Per-variant artwork substitution the content builders consume. */
+export type WatermarkArtwork = {
+    image?: string;
+    textColor: MosaicColor;
+};
+/** One stamp layer to emit: artwork + its alpha realization. */
+export type AdaptiveLayerSpec = {
+    /** stampOnMedia children key / editor label suffix. */
+    key: "wm" | "light" | "dark";
+    artwork: WatermarkArtwork;
+    /** Time-varying overlay.alpha (never paired with enable — it hard-cuts the ramp). */
+    alphaExpr?: string;
+    /** Constant fast path (image steps). */
+    opacity?: number;
+};
+export type AdaptiveKnobs = {
+    variant: "single" | "auto";
+    windowing: "always" | "windows";
+    opacity: number;
+    fadeMs: number;
+    crossfadeMs: number;
+    lumaThreshold: number;
+    minGapMs: number;
+    coverageOverride?: number;
+    /** `imageDark ?? image` + `textColor` (the user's primary styling). */
+    artworkPrimary: WatermarkArtwork;
+    /** `image` + `textColorOnLight` (for bright regions). */
+    artworkOnLight: WatermarkArtwork;
+};
+/**
+ * Assemble the adaptive layers for one step.
+ *
+ * Video: windows mode plans slot-aligned appearances (coverage tiers,
+ * gap constraint) with per-window variant picks; always mode keeps the
+ * stamp on with an entrance fade and (auto) a per-scene crossfade
+ * between the two artworks. Image: no time axis — one constant layer,
+ * variant picked once from the overall region luma.
+ */
+export declare function buildAdaptiveLayerSpecs(args: {
+    isVideo: boolean;
+    /** Probed input duration (video steps). */
+    videoDurMs?: number;
+    entry?: WatermarkLumaEntry;
+    knobs: AdaptiveKnobs;
+}): AdaptiveLayerSpec[];