Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: preserve film textures and blending inside isolated previews

Adam Eivy70a5241e7942
diff --git a/docs/HTML_COMPOSITIONS.md b/docs/HTML_COMPOSITIONS.md
index 354300623d..9475431561 100644
--- a/docs/HTML_COMPOSITIONS.md
+++ b/docs/HTML_COMPOSITIONS.md
@@ -315,6 +315,9 @@ what the preview shows and what the render bakes:
into the OS-isolated preview worker. Playing frames use the same lightweight
motion layers as the animatic: CSS focus/tone/saturation and weave on the
root, with pointer-transparent overlays above document and lyric layers.
+ Noise tiles are rasterized once into canvases from trusted inline filters,
+ preserving the worker's image restrictions. Each overlay blends directly
+ with the document and preceding layers rather than an isolated overlay group.
Pause, scrub and frame stepping restore the exact SVG filter. This mode is
preview-only; final renders remain exact and generated HTML stays isolated.
- **The storyboard animatic** (the docked preview for footage projects) shows
diff --git a/server/lib/filmLook.browser.test.js b/server/lib/filmLook.browser.test.js
index 065642f19f..35f4e7fc72 100644
--- a/server/lib/filmLook.browser.test.js
+++ b/server/lib/filmLook.browser.test.js
@@ -1,8 +1,18 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
import { chromium } from 'playwright-core';
+import sharp from 'sharp';
import { browserSuiteCanRun } from './browserSuiteGate.js';
import { filmLookFilterMarkup, filmLookPreset, filmLookRuntimeSource } from './filmLook.js';
+import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from './mockPathsDataRoot.js';
+
+vi.mock('./paths.js', async (original) => makePathsProxy(await original(), {
+ dataRoot: () => lazyTempDataRoot('portos-film-look-browser-'),
+}));
+vi.mock('../services/browserService.js', () => ({ loadConfig: async () => ({ chromePath: chrome }), cdpRequest: vi.fn() }));
+afterAll(() => cleanupTempDataRoots());
const chrome = [process.env.CHROME_PATH, chromium.executablePath(),
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/usr/bin/google-chrome', '/usr/bin/chromium',
@@ -19,25 +29,63 @@ describe.skipIf(!canRun)('film look runtime in Chrome', () => {
beforeAll(async () => { browser = await chromium.launch({ executablePath: chrome, headless: true }); });
afterAll(async () => { await browser?.close(); });
+ it('paints cached grain and tape under the worker media CSP and blends the cast with the document pixels', async ({ signal }) => {
+ const { PATHS } = await import('./paths.js');
+ const { openComposition } = await import('../services/htmlComposition/browser.js');
+ const directory = 'composition';
+ await mkdir(join(PATHS.data, directory), { recursive: true });
+ const base = '<div style="position:fixed;inset:0;background:#406080"></div>';
+ await writeFile(join(PATHS.data, directory, 'index.html'), html('', base));
+ // The same browser entry point and default CSP used by the preview worker;
+ // this trusted fixture needs no OS jail (egress has its own contract suite).
+ const page = await openComposition(directory, { ownedBrowser: true, mediaMode: 'code-only',
+ signal, initScripts: [filmLookRuntimeSource()],
+ });
+ const reference = await browser.newPage({ viewport: { width, height } });
+ const shot = async () => Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64');
+ try {
+ await page.send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false });
+ const textures = await page.evaluate(`(() => {
+ window.__portosFilmLook.apply({ grain: 1, tapeNoise: 1 });
+ window.__portosFilmLook.playback(true);
+ const canvases = [...document.querySelectorAll('[data-portos-film-look-motion] canvas')];
+ const pixels = canvases.map((canvas) => new Set(canvas.getContext('2d').getImageData(0, 0, 100, 100).data).size);
+ window.portosComposition = { fps: 30, seek() {} }; window.portosComposition.seek(1);
+ return { pixels, reused: canvases.every((canvas, i) => canvas === document.querySelectorAll('[data-portos-film-look-motion] canvas')[i]) };
+ })()`);
+ expect(textures.reused).toBe(true);
+ expect(textures.pixels).toHaveLength(2);
+ expect(textures.pixels.every((colors) => colors > 20)).toBe(true);
+ const noise = await sharp(await shot()).raw().toBuffer();
+ await page.evaluate("window.__portosFilmLook.apply(null)");
+ expect(Buffer.compare(noise, await sharp(await shot()).raw().toBuffer())).not.toBe(0);
+ await page.evaluate("window.__portosFilmLook.apply({ cast: 1, castColor: '#ff9a3c' })");
+ await reference.setContent(html('', base + '<div style="position:fixed;inset:0;background:#ff9a3c;mix-blend-mode:soft-light"></div>'));
+ expect(Buffer.compare(await sharp(await shot()).raw().toBuffer(), await sharp(await reference.screenshot()).raw().toBuffer())).toBe(0);
+ // Image restrictions remain enforced even after trusted textures paint.
+ await page.evaluate("const image = document.createElement('img'); image.src = 'data:image/svg+xml,%3Csvg/%3E'; document.body.appendChild(image)")
+ .catch((error) => expect(error.message).toMatch(/Refused composition request: data/));
+ await vi.waitFor(() => expect(() => page.check()).toThrow(/Refused composition request: data/));
+ } finally { await page.close(); await reference.close(); }
+ }, 30000);
+
// Uniquely pins the rendered pixels, rather than just checking unchanged SVG source.
- it('keeps exact render captures byte-identical to the standalone filter across frames and restores them after playing', async () => {
+ it.each([12, 47])('keeps exact render capture at frame %i byte-identical and restores it after playing', async (frame) => {
const page = await browser.newPage({ viewport: { width, height } });
const reference = await browser.newPage({ viewport: { width, height } });
try {
const look = filmLookPreset('neon-rain');
await page.setContent(html(`<script>${filmLookRuntimeSource(look)}</script>`, picture + composition));
- for (const frame of [12, 47]) {
- const exact = filmLookFilterMarkup(look, { frame, width, height });
- await reference.setContent(html('', picture + exact.svg));
- await reference.evaluate((filter) => { document.documentElement.style.filter = filter; }, exact.css);
- await page.evaluate((n) => globalThis.portosComposition.seek(n / 30), frame);
- const expected = await reference.screenshot();
- expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
- await page.evaluate(() => globalThis.__portosFilmLook.playback(true));
- expect(await page.evaluate(() => document.documentElement.style.filter)).not.toContain('url(');
- await page.evaluate(() => globalThis.__portosFilmLook.playback(false));
- expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
- }
+ const exact = filmLookFilterMarkup(look, { frame, width, height });
+ await reference.setContent(html('', picture + exact.svg));
+ await reference.evaluate((filter) => { document.documentElement.style.filter = filter; }, exact.css);
+ await page.evaluate((n) => globalThis.portosComposition.seek(n / 30), frame);
+ const expected = await reference.screenshot();
+ expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
+ await page.evaluate(() => globalThis.__portosFilmLook.playback(true));
+ expect(await page.evaluate(() => document.documentElement.style.filter)).not.toContain('url(');
+ await page.evaluate(() => globalThis.__portosFilmLook.playback(false));
+ expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
} finally { await page.close(); await reference.close(); }
}, 30000);
@@ -52,7 +100,7 @@ describe.skipIf(!canRun)('film look runtime in Chrome', () => {
globalThis.__portosFilmLook.playback(true);
const overlay = document.querySelector('[data-portos-film-look-motion]');
const grain = overlay.querySelector('[data-film-look-layer="grain"]');
- const image = grain.style.backgroundImage;
+ const canvas = grain.firstElementChild;
globalThis.portosComposition.seek(1);
const hit = document.elementFromPoint(195, 100);
// Temporarily make only the vignette interactive to ask Chrome which layer paints on top.
@@ -63,7 +111,7 @@ describe.skipIf(!canRun)('film look runtime in Chrome', () => {
return {
last: document.documentElement.lastElementChild === overlay,
hit: hit.id, top: top.dataset.filmLookLayer,
- reused: grain === overlay.querySelector('[data-film-look-layer="grain"]') && grain.style.backgroundImage === image,
+ reused: grain === overlay.querySelector('[data-film-look-layer="grain"]') && grain.firstElementChild === canvas,
filter: document.documentElement.style.filter,
pointers: [...overlay.children].map((child) => getComputedStyle(child).pointerEvents),
};
diff --git a/server/lib/filmLook.js b/server/lib/filmLook.js
index 83d65746b8..0464fa593b 100644
--- a/server/lib/filmLook.js
+++ b/server/lib/filmLook.js
@@ -496,6 +496,34 @@ export function filmLookRuntimeSource(look = null) {
if (overlays) { overlays.remove(); overlays = null; }
if (savedTransform !== null) { root.style.transform = savedTransform; savedTransform = null; }
};
+ const paintTile = (el, layer, size) => {
+ const key = layer.image + ':' + size.width + ':' + size.height;
+ if (el._filmLookTileKey === key) return;
+ el._filmLookTileKey = key;
+ // Rasterize our own SVG filter directly into canvas once. Image URLs are
+ // forbidden by the worker's code-only CSP; no image permission is needed.
+ const id = 'portos-film-look-tile-' + layer.key;
+ const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+ svg.style.cssText = 'position:absolute;width:0;height:0;pointer-events:none';
+ svg.innerHTML = decodeURIComponent(layer.image.slice(layer.image.indexOf(',') + 1))
+ .replace(/id="[gt]"/g, 'id="' + id + '"').replace(/url\\(#(?:g|t)\\)/g, 'url(#' + id + ')');
+ document.documentElement.appendChild(svg);
+ const tile = document.createElement('canvas');
+ [tile.width, tile.height] = layer.size;
+ const context = tile.getContext('2d');
+ context.filter = 'url(#' + id + ')';
+ context.fillRect(0, 0, tile.width, tile.height);
+ context.filter = 'none';
+ svg.remove();
+ const canvas = el._filmLookCanvas || document.createElement('canvas');
+ canvas.width = Math.ceil(size.width * 2); canvas.height = Math.ceil(size.height * 2);
+ canvas.style.cssText = 'width:200%;height:200%;pointer-events:none';
+ const paint = canvas.getContext('2d');
+ paint.fillStyle = paint.createPattern(tile, 'repeat');
+ paint.fillRect(0, 0, canvas.width, canvas.height);
+ if (!el._filmLookCanvas) el.appendChild(canvas);
+ el._filmLookCanvas = canvas;
+ };
const drawMotion = (root, size) => {
if (host) { host.remove(); host = null; }
const built = motion(look, size);
@@ -506,7 +534,8 @@ export function filmLookRuntimeSource(look = null) {
overlays = document.createElement('div');
overlays.dataset.portosFilmLookMotion = '1';
overlays.setAttribute('aria-hidden', 'true');
- overlays.style.cssText = 'position:fixed;inset:0;overflow:hidden;pointer-events:none;z-index:2147483647';
+ // A stacking context here would make blends see only the overlay group.
+ overlays.style.cssText = 'display:contents;pointer-events:none';
}
// A root child after body also paints after max-z-index lyrics/title layers.
if (root.lastElementChild !== overlays) root.appendChild(overlays);
@@ -515,22 +544,20 @@ export function filmLookRuntimeSource(look = null) {
for (const [index, layer] of built.overlays.entries()) {
let el = [...overlays.children].find((child) => child.dataset.filmLookLayer === layer.key);
if (!el) { el = document.createElement('div'); el.dataset.filmLookLayer = layer.key; }
- // Reuse the nodes and tile URLs across frames: only the tile transform changes.
- el.style.position = 'absolute'; el.style.pointerEvents = 'none';
+ // Each layer blends with the document and all preceding film layers.
+ el.style.position = 'fixed'; el.style.pointerEvents = 'none'; el.style.overflow = 'hidden';
el.style.opacity = layer.opacity; el.style.mixBlendMode = layer.blend;
el.style.left = '0'; el.style.top = '0';
- el.style.width = layer.kind === 'tile' ? '200%' : '100%';
- el.style.height = layer.kind === 'tile' ? '200%' : '100%';
+ el.style.width = '100%'; el.style.height = '100%';
if (layer.kind === 'flat') el.style.backgroundColor = layer.color;
if (layer.kind === 'gradient') el.style.backgroundImage = layer.gradient;
if (layer.kind === 'tile') {
- el.style.backgroundImage = 'url("' + layer.image + '")';
- el.style.backgroundSize = layer.size[0] + 'px ' + layer.size[1] + 'px';
- el.style.backgroundRepeat = 'repeat';
- el.style.transform = 'translate(' + (-layer.shift[0] * 50) + '%, ' + (-layer.shift[1] * 50) + '%)';
+ paintTile(el, layer, size);
+ el._filmLookCanvas.style.transform = 'translate(' + (-layer.shift[0] * 50) + '%, ' + (-layer.shift[1] * 50) + '%)';
}
- el.style.zIndex = String(index);
- if (el.parentNode !== overlays) overlays.appendChild(el);
+ el.style.zIndex = '2147483647';
+ // A slider can add an earlier layer after later ones already exist.
+ if (overlays.children[index] !== el) overlays.insertBefore(el, overlays.children[index] || null);
}
};
const draw = () => {
diff --git a/server/lib/filmLook.test.js b/server/lib/filmLook.test.js
index fe9fbf903c..2695c28d6d 100644
--- a/server/lib/filmLook.test.js
+++ b/server/lib/filmLook.test.js
@@ -92,8 +92,10 @@ describe('film look runtime', () => {
const element = () => ({
style: { filter: '', transform: '' }, dataset: {}, children: [], isConnected: false,
setAttribute() {},
+ getContext: () => ({ fillRect() {}, createPattern() {} }),
get lastElementChild() { return this.children.at(-1); },
appendChild(child) { child.remove(); this.children.push(child); child.parent = this; child.parentNode = this; child.isConnected = true; },
+ insertBefore(child, before) { child.remove(); this.children.splice(before ? this.children.indexOf(before) : this.children.length, 0, child); child.parent = this; child.parentNode = this; child.isConnected = true; },
remove() { if (this.parent) this.parent.children = this.parent.children.filter((child) => child !== this); this.isConnected = false; },
});
const root = Object.assign(element(), { clientWidth: 390, clientHeight: 219 });
@@ -112,14 +114,15 @@ describe('film look runtime', () => {
expect(root.style.filter).not.toContain('url(');
const overlays = root.lastElementChild;
const grain = overlays.children.find((child) => child.dataset.filmLookLayer === 'grain');
- const originalImage = grain.style.backgroundImage;
- const originalShift = grain.style.transform;
+ const canvas = grain.children[0];
+ const originalShift = canvas.style.transform;
context.portosComposition.seek(0.5);
expect(root.lastElementChild).toBe(overlays);
expect(overlays.children.find((child) => child.dataset.filmLookLayer === 'grain')).toBe(grain);
- expect(grain.style.backgroundImage).toBe(originalImage);
- expect(grain.style.transform).not.toBe(originalShift);
- expect(overlays.style.cssText).toContain('pointer-events:none;z-index:2147483647');
+ expect(grain.children[0]).toBe(canvas);
+ expect(canvas.style.transform).not.toBe(originalShift);
+ expect(overlays.style.cssText).toContain('display:contents;pointer-events:none');
+ expect(overlays.children.every((child) => child.style.zIndex === '2147483647')).toBe(true);
expect(overlays.children.every((child) => child.style.pointerEvents === 'none')).toBe(true);
api.playback(false);
expect(root.style.filter).toBe(exact.css);