Skip to content

Safe projects roadmap

Priority: now, before removing the code-execution question or accepting projects from unknown sources without it.

Status: in progress (18 open, 2 done). The opaque frame and CSP, CLI declaration isolation, font transfer, deadlines, per-plugin tool isolation and initial bridge limits are implemented. Full execution-path coverage, capability validation, resource budgets, recovery and the release gate remain open.

Shipped pack data boundary (2026-11-09): a built-in pack’s data reader now accepts only a simple shipped module name and a plain relative file path. It rejects URL escapes before fetching and streams at most 8 MiB, cancelling a larger response. Tests cover traversal, URL syntax, a forged module name and an oversized response. The data reader’s aggregate work and other plugin capabilities still keep steps 3 and 4 open.

Shipped pack module bound (2026-11-09): the editor’s own preflight read of a shipped pack module now stops at 1 MiB and cancels a larger stream, matching the isolated worker’s source limit. A test proves oversized source is refused before it is decoded on the trusted page. Other import and aggregate budgets keep step 4 open.

Shipped pack index bound (2026-11-09): the editor now streams the built-in pack index with a 1 MiB cap and checks the entries before caching them. An oversized or forged index leaves packs unavailable with an error instead of supplying paths or commands to the editor. The test also accepts the actual shipped index. Other resource and capability limits remain open.

Installed plugin picker bound (2026-11-09): before a selected plugin or installed-plugin backup is buffered, the editor now checks the file’s reported size against the reader’s existing 1 MiB module and 64 MiB package/backup limits. A test proves oversized selections are refused without calling text() or arrayBuffer(). Stored plugin reads, package inflation and aggregate memory still require further work in step 4.

Plugin archive entry bound (2026-11-09): package and installed-plugin backup readers now refuse more than 2,000 zip entries from metadata before inflating the excess. A package’s top-level JavaScript entry above 1 MiB is also refused before inflation. Tests cover both archive counts and a compressed oversized module. Expanded bytes were already bounded, while aggregate retained data and other import paths keep step 4 open.

Installed-plugin backup creation bound (2026-11-09): backup creation now checks the same 2,000-entry limit and 128 MiB expanded-byte ceiling before compression, then rejects a compressed result above 64 MiB. Tests prove that excess entries and bytes stop before zipSync. The editor may still retain multiple plugins and copies in memory outside this one archive operation, so step 4 remains open.

Plugin package creation bound (2026-11-09): writePluginPackage now checks the reader’s entry, module and expanded-byte limits plus safe data paths before compressing; the compressed result must also fit 64 MiB. Tests cover the count, source, path and expanded-byte refusals. Other aggregate host allocations and recovery keep step 4 open.

Stored plugin read bound (2026-11-09): refreshing installed plugins now skips a module larger than 1 MiB from the storage listing before reading it. The folder reader checks the object’s size before arrayBuffer(), and the shared library HTTP reader streams with a caller-supplied cap (1 MiB for plugin modules), cancelling excess bytes. Tests cover the skipped request and streaming cancellation. Companion data and library files retain the project’s 95 MiB file ceiling; aggregate retention remains open in step 4.

Plugin companion data bound (2026-11-09): the installed-plugin companion module now accepts at most 2,000 safe relative file paths and 128 MiB of decoded bytes. Its encoder writes binary strings in chunks rather than spreading a large typed array into one call, and refuses a companion source above the library file ceiling. Tests cover a 100,000-byte round trip, traversal, count and aggregate size. Multiple installed plugins may still retain substantial data together, so step 4 remains open.

Plugin package path alignment (2026-11-09): package readers and writers now reject dot segments, encoded URL syntax, queries, fragments, control characters and paths longer than the project file limit. Tests cover forged zip entries and direct package creation. These paths cannot be copied into project files through the installed-plugin flow; other file capabilities keep step 3 open.

Plugin backup name alignment (2026-11-09): backup creation now accepts only the same simple installed-plugin file names that backup restoration permits. A malformed name is rejected before compression; tests cover traversal, subfolders and URL syntax. Other archive and project capabilities keep step 3 open.

Installed-plugin network redirect (2026-11-09): a plugin’s approved external origin now uses redirect: 'error' with credentials omitted. A response cannot silently move its request to an undeclared origin, even if the plugin asks to follow redirects. A focused test checks the trusted fetch options. Provider routes and other external capabilities still keep step 3 open.

Boundary work (2026-11-06): node scripts/verify-project-boundary.mjs exercises an HTTP-served CSP and an allow-scripts iframe. The frame’s message origin is null; reads of the parent DOM, cookies, localStorage, IndexedDB and CacheStorage throw SecurityError. A private API request is refused by connect-src 'none'. A module worker created from a data: URL has opaque origin, cannot fetch that API, and retains OffscreenCanvas and WebGL2 in Chromium. A blob: module worker failed to start in this setup, so the transport uses data:. The editor and CLI now serve /project-sandbox.html with a network-denying policy; browserHost transfers its bundled worker and approved local plugin source into that frame. The CLI’s real plugin render and boundary tests pass under Chrome and Edge. The served-route tests also refuse direct fetch, no-CORS fetch, XHR, WebSocket, EventSource where available, remote module imports and a nested worker’s fetch without reaching a private route. An actual project module attempting IndexedDB access and a private fetch during initialization receives SecurityError and sends no request. In local Wrangler, HTML assets redirect to extensionless URLs, so the Cloudflare Worker explicitly serves both sandbox paths with the CSP; the real local response was checked. The desktop custom protocol attaches the same header. Production deployment, desktop webviews, Firefox/Safari, the remaining native/CLI execution paths and media/model transfer remain to be tested before the box is checked. To check on a device: Windows/WebView2 and macOS/WKWebView, including whether native APIs are visible inside the frame or worker.

CLI native-import removal (2026-11-06): archive and folder validation now load plugin declarations through the same browser sandbox. The Node registry holds schema and functions that refuse execution; project code runs only in the isolated worker, including during validate, check and pack/unpack validation. A plugin that loops during initialization is terminated after the declaration deadline. The CLI’s actual plugin render continues to use the isolated browser worker. Plugin behavior needed by Node-only checks or vector comparisons must be bridged explicitly before those operations can claim full parity; the refusal is deliberate and the roadmap remains open.

Font transfer (2026-11-06): the trusted page fetches font bytes only from the current project’s file root or a local Blob and sends them in order before draw requests. The worker creates FontFace from those bytes and no longer fetches the document’s font URL itself. Chrome and Edge tests confirm one approved read and that naming the private API as a font triggers a refusal before any request reaches it. Other approved resources still need explicit host capabilities; this does not close step 1. Model transfer (2026-11-06): the trusted asset loader now reads model bytes with a 32 MiB limit, refusing URLs outside the current project root (or an owned Blob) when isolation is enabled. Document snapshots copy these bytes to the worker; model.3d parses them there without calling fetch, including during whole-frame rendering where node preload does not run. Unit tests cover the project-path refusal, oversized streaming cancellation, snapshot refresh and network-free model parsing. node bench/safe-projects/model-sandbox.mjs renders a colored .glb through the real CLI browser worker with a plugin present (760 colored pixels). Native-device and other media-path checks still keep step 1 open. CLI browser import fix (2026-11-06): the CLI now obtains plugin declarations from the opaque worker before opening its trusted renderer, and configures that renderer to skip project module imports. The model integration probe has a plugin that throws if imported where document exists; the export succeeds through the worker. The six-frame web-scene plugin composite also still succeeds. The CLI no longer accepts a sandbox=0 query escape for projects with plugins. Expression-only projects and the remaining browser/native execution paths still keep step 2 open. Isolated asset path check (2026-11-06): before the trusted renderer loads an image, font, JSON, LUT, audio, video, model or non-plugin module for an isolated document, it now checks that the URL is within the document’s project folder or an owned Blob. A video proxy receives the same check. A test proves that a JSON asset naming /api/private is refused before fetch; the model browser probe still renders. Other host capabilities, especially tool requests and files outside the project, remain in step 3.

CLI native plugin file path (2026-11-07): folder validation now resolves a plugin file and the project root through the filesystem before reading module source, refusing a symbolic link outside the project. CLI registry and asset readers use the server’s shared mount resolver, which also enforces each explicit mount’s real path. This closes a native file-read discrepancy; broader cross-project capabilities remain open.

CLI native export asset path (2026-11-07): the SVG/Lottie file reader now refuses relative traversal, URL-like paths and symlinks outside the project before reading asset bytes. Explicit mounts continue through the CLI’s approved mount resolver. A test reads an in-project font and refuses both an outside ../ path and a junction to a private folder. Other native file paths and host capabilities remain open.

CLI native export asset size (2026-11-07): before the SVG/Lottie reader buffers a file, it now checks its length against the isolated loader’s limits for images/models (32 MiB), fonts (16 MiB) and JSON (8 MiB), with a 95 MiB ceiling for other project assets. An oversized sparse font is rejected before readFileSync. Aggregate export memory remains open.

CLI mount containment (2026-11-07): the local render server now uses path-relative containment rather than a string prefix, and refuses an existing project symlink that resolves outside its mount. Project config cannot replace a protected /project/ path with another mount. Unit tests cover sibling-prefix traversal, parent traversal, a directory symlink and a forged config mount. Explicit non-project mounts remain supported; this closes one path to another folder, not the full cross-project and native boundary proof in step 1. Asset allocation bounds (2026-11-07): the loader now has at most eight asset loads in flight; an isolated image above 8,192 pixels on either side or 16 million pixels overall is refused before creating an ImageBitmap. Tests exercise both limits. Browser image decoding already occurred by the time its dimensions are known; graphics memory and aggregate allocations therefore remain open in step 4.

Bounded isolated image files (2026-11-07): the loader now streams an image into a Blob with a 32 MiB cap before giving it to the browser decoder. An oversized stream is cancelled before Image construction; the existing decoded-dimension check remains. The six-frame web-scene plugin composite still renders through the real CLI browser after this change. Blob bytes, decoded pixels and worker copies can coexist, so aggregate graphics memory remains open in step 4.

Retained image budget (2026-11-07): an isolated project now retains at most 64 million decoded image pixels (256 MiB at RGBA8), in addition to the per-image and compressed-file caps. A newly decoded surface that exceeds the total is closed and refused; surfaces are closed when their assets change or disappear. Tests cover the aggregate refusal and release. This bounds the loader’s retained images, while temporary decoder buffers, worker copies, GPU allocations and video remain outside this count; step 4 stays open.

Asset inventory bound (2026-11-07): an isolated document now refuses more than 4,096 asset records before any asset load starts. The test builds 4,097 entries and proves that no request was made. This limits one route to repeated host work; it does not bound temporary browser or GPU memory, so step 4 remains open.

Video dimensions and release (2026-11-07): an isolated video track above 8,192 pixels on either side or 16 million pixels overall is refused before the decoder pool starts; an input rejected during opening is disposed. When a video asset changes or disappears, the loader disposes its former decoder. Tests cover the dimension gate, option passed by the loader and removal. Video file length, temporary decoded surfaces and platform memory remain open in step 4.

Bounded isolated data assets (2026-11-07): font responses stop at 16 MiB, JSON and LUT responses at 8 MiB. The loader checks declared length and cancels a stream when its actual bytes cross the limit; tests exercise each oversized resource. Image decode, video buffers and aggregate graphics memory remain open in step 4. Bitmap bridge budget (2026-11-07): each page-to-sandbox message and draw/frame response now has a separate 256 MiB budget for the estimated RGBA bytes of its ImageBitmap surfaces; this does not mistake a bitmap for a small plain-data object. A test covers refusal in both directions. Document images are cloned into the worker so the trusted page retains its loaded copy; per-frame video bitmaps can still transfer ownership. Actual browser/GPU allocation, repeated messages and per-project totals remain open in step 4. The worker now waits for each supplied FontFace to finish loading before the first frame, plugin draw or vector export uses it. A font that fails to load stops that operation with its error rather than silently drawing a fallback face.

Startup and call deadlines (2026-11-06): if the iframe does not start its worker in ten seconds, the host rejects waiting operations and removes it. Plugin loading has a 15-second deadline; checks, drawing, frame renders and vector exports have 30 seconds; tools have 120 seconds. A timeout closes the host so the next attempt creates a fresh isolated frame. A browser test serves a blank frame to prove the startup refusal; fake-time tests cover load, draw, check, tool, whole-frame render and vector export timeouts. Resource budgets and a user-facing recovery flow remain open in step 4.

Bridge input checks (2026-11-06): unknown worker requests no longer fall through to the check’s asset-data capability. Host file requests reject absolute paths, traversal and URL-like paths before invoking the project context; file payloads and network request fields have size and shape bounds. A test sends forged requests during an active check/tool call and verifies that no private data or file action is reached. This input check alone did not establish plugin identity; later paragraphs record the separate worker and replay checks.

Host resource bounds (2026-11-06): at most 64 worker calls can wait at once; the next is refused before it reaches the worker. The host refuses a project module larger than 1 MiB before sending its source into the opaque frame. Unit and browser tests exercise these limits. Total message size, graphics allocations and a user-facing recovery path remain open in step 4.

CLI declaration input bound (2026-11-07): folder and archive plugin validation now refuse more than 64 plugins and a plugin source over 1 MiB before reading or decoding it in the native CLI process. This matches the browser host’s module limit. A test covers the oversized archive bytes and an oversized file on disk. Aggregate memory and recovery remain open.

Resource limits stated (2026-11-09): plugin-isolation.md now lists the deadlines, size bounds and pending-call cap the host enforces and says plainly what the platform cannot: a hard memory or CPU cap on a worker. The earlier “bounded memory” claim belongs to option (d), not to the chosen worker.

Sandbox stop notice (2026-11-09): when the plugin sandbox stops for a reason (a deadline, a crash, a refused message), the editor shows what stopped and says the saved project and unsaved edits are untouched. The next call starts a fresh sandbox, which is the retry; the way to open without the plugin is to remove it from the project. The sandbox never touches the document, so no work is lost. A device test of a real runaway script remains open under step 6.

Plugin-backup expansion (2026-11-06): the installed-plugin backup reader now refuses a compressed file over 64 MiB and a declared expanded total over 128 MiB before inflating entries. The project archive and single-plugin package readers already had expansion limits. Other import paths, total bridge message size, graphics allocations and recovery still keep step 4 open.

Project archive entry bound (2026-11-07): unpackProject now refuses more than the project’s 2,000-file limit while reading zip metadata, before inflating the excess entry. This closes the many-small-files gap left by the existing compressed and expanded byte limits. Other resource and recovery gates remain open.

Project archive creation bound (2026-11-07): packProject now checks the same 2,000-file count, each file’s allowed length and the aggregate expanded-byte budget before compressing. This prevents an oversized in-memory project from starting a costly zip operation. Other resource and recovery gates remain open.

Bridge request concurrency (2026-11-06): one active tool or check can have at most 16 host requests waiting at once. The host refuses replayed request IDs before repeating a file or network operation, and no longer sends an answer back after the call has ended. This is one part of the broader capability validation still open in step 3.

Worker response envelopes (2026-11-06): the host checks the shape and basic bounds of declarations, call IDs, draw result lists, progress, and error fields before using them. A malformed response closes the isolated frame and rejects waiting work. Plugin identity and complete capability checks still keep step 3 open.

Worker result budget (2026-11-06): the host traverses returned declarations, tool outputs, drawings and vector exports with an 8 MiB limit for nested plain data and a 10,000-entry limit. Returned ImageBitmaps are checked for dimensions but their actual GPU allocation is controlled by the browser; they are not counted as plain bytes. Message transfer allocations and platform memory limits still keep steps 3 and 4 open.

Expression-only picture path (2026-11-06): when a user has explicitly enabled the experimental sandbox preview, a project without plugins now selects the same sandboxed picture path for stills and raster exports. Previously the export selector required a plugin even under that opt-in. The default remains off; page-side mirror evaluation, sound evaluation and vector export can still evaluate expressions outside the boundary, so step 2 is open.

CLI expression-only rendering (2026-11-07): the CLI render page now selects the opaque sandbox for any document expression, including expressions nested in distributed instance parameters, even when there is no plugin. A real Chrome render test observes the sandbox document request and verifies the distributed colours in its final picture. This removes one trusted-page path for CLI stills and raster frames; other evaluation paths and the editor default keep step 2 open.

CLI module transfer (2026-11-07): with isolation selected, the trusted asset loader does not import module assets. The CLI now transfers every project module through the host’s bounded, project-path-approved load channel and runs Free code layers in the opaque worker; their init hook runs there once per document snapshot. A real Chrome test serves a module that throws if document is visible, renders its red pixels twice and verifies one module read and one initialization. The evaluator now distinguishes code.params from a component’s nested params address. Editor and other export paths still need the same coverage before step 2 closes.

CLI in-page document switch (2026-11-07): TRAMME.load now refuses a document that would change whether its already-open renderer is isolated. A real Chrome test starts on a clean document, tries to load a Free code module, and confirms that the trusted page reads no module and keeps its original document. An isolated-to-isolated switch loads the new module declarations before updating the renderer. Broader CLI path coverage remains open.

Isolated layer preparation (2026-11-07): the trusted renderer no longer calls any node’s load hook when its modules are sandboxed. Even a built-in model’s load first evaluated all of that layer’s properties, which could run an expression on the trusted page before a frame was requested. A real Chrome test places an expression on model.3d.height and confirms that opening the isolated document does not touch the page DOM. The worker still prepares Free code layers for isolated rendering; other editor mirror evaluations remain open.

Trusted mirror evaluation (2026-11-07): Evaluator now has a fail-closed option that refuses expressions before compilation or execution. The isolated renderer uses it, as do the editor’s viewport, inspector, graph, retouch view, review checks, critique and authoring tools when sandbox preview is selected. A test uses an expression that would write to globalThis and confirms it is refused without executing. The inspector’s property rows now ask the isolated worker for a value when local evaluation is refused, and discard a reply for a different document, composition, address or time. A worker-protocol test evaluates a real expression and propagates an invalid-address error. Other views still lack worker-backed geometry or values; the setting is still opt-in, so step 2 remains open.

Vector preflight guard (2026-11-07): the editor’s vector preflight helper now uses the same expression refusal when its document is isolated, even if it is called without the browser export entry point’s earlier expression check. A test attempts a global write through a plugin node’s property and confirms the helper refuses it before execution. Isolated expression-based SVG/Lottie export still needs worker-side conversion; step 2 remains open.

Bounded tool text reads (2026-11-07): a sandboxed tool’s readText capability now streams the project file with an 8 MiB limit before decoding it, cancelling an oversized open stream instead of first filling a string in the trusted page. Tests cover cancellation, a normal read and a missing file. Other host reads and aggregate capability budgets remain open in step 4.

Project-bound tool capabilities (2026-11-07): the editor now captures the project ID and document URL when it gives a tool its context. File reads, file lists, writes, URLs, stills and transcript requests refuse a stale context after the user opens another project or another location for the same project. A read that began earlier also refuses to return its result after the change. The runner also discards a completed tool result and checks again after asynchronous proposal preparation, so old operations are not proposed on the new document. Tests check both changes, an in-flight read and a late proposal without making a request to the newly opened project. Long-running transcription and other editor-owned work still need a broader project-switch audit; step 3 remains open.

Transcription project switch (2026-11-07): a transcription job is now keyed by project identity as well as asset ID. If the user opens another project while a transcription prompt or model call waits, the old job refuses to start or commit on the newly opened document. The job checks again after file listing and upload; an upload already started may leave an unreferenced file in the former project, so cleanup and other long-running editor work remain open. A regression test switches projects while the permission prompt is open and confirms no transcription starts in the new project.

Project-bound file listing and upload (2026-11-07): the file list returned by takenPaths() now remembers the project ID and document URL it belongs to. upload() refuses a list from a previous project, writes to the captured project ID, and refuses to return a path if the user switches projects during the write. Tests cover a switch between listing and upload and another while an upload is pending. A write already started may leave an unreferenced file in the former project; cleanup and callers’ remaining document updates still need review, so step 3 remains open.

Attachment switch (2026-11-07): pending message attachments are cleared when the open project or its document URL changes. An attachment still hashing or uploading checks that project again before adding an asset or a pending message reference. Tests cover clearing an unsent attachment and a delayed upload that completes after another project opens. Other asynchronous import/export callers still need the same audit, so step 3 remains open.

Browser export project switch (2026-11-07): a browser export now captures its document, registry, composition, project ID and document URL before loading the export code. Finished results are refused after a project switch, progress from the old export is not shown on the new project, and a finished file cannot be kept under another project’s renders/. The batch export takes its list of shorts from the captured document and checks the project between exports and before saving. Tests exercise a delayed result and the same project ID opened from another URL. Queued exports and other asynchronous editor actions still need review; step 2 and step 3 remain open.

File-panel import switch (2026-11-07): Lottie and ordinary file imports now check the starting project after reading and uploading files before committing new compositions or assets. Pack addition and update pin the project ID before their download and write, and the optional video proxy offer stops after a project switch. A test completes an image upload after another project opens and confirms the imported asset is not added to the new document. A file already sent to the old project may remain unreferenced; other asynchronous editor actions remain to audit, so step 3 stays open.

Voiceover project switch (2026-11-07): a recording now captures its opening project before microphone permission, refuses to proceed after a switch during count-in, after recording stops, or after WAV conversion, and writes the finished take only to the captured project. It checks again before adding the take to the document. A delayed microphone permission test confirms that the granted stream is released after a switch. A recording already in progress still waits for its stop event; a write already in flight may leave an unreferenced file in the old project. Other asynchronous editor actions remain to audit.

Version project switch (2026-11-07): the versions panel pins its opening project ID and document URL, including when its rows remain visible after navigation. Version-index reads and the create, restore and delete actions check that identity before acting and after their awaited save, confirmation, read or write before proceeding to another operation or reloading the page. A delayed index-read test confirms that an old project’s versions cannot be returned after another project opens. A snapshot write already in flight may leave an unreferenced file in the old project; other asynchronous actions remain to audit.

Plugin copy and filler review switch (2026-11-07): copying an installed plugin into a project now pins its project ID and document URL across every file write and before committing the plugin copy. The filler-cuts panel pins its file read and displayed list to the same identity, so an old project’s delayed response cannot populate the new project’s review. A UI test completes the old read after navigation. Files already written to the old project may remain unreferenced; other asynchronous actions remain to audit.

Built-in assistant file tools (2026-11-08): list_files, read_file and write_file now pin the project before an awaited API request and refuse their result after navigation. The media-cut tool pins its transcript read and remapped file write, and refuses to propose its edit after a switch. Transcript lookup checks the project again after transcription and JSON loading, resolving its URL against the captured document URL. Tests complete a file listing and a plugin write after another project opens. Other assistant media and rendering operations still need the same audit, so step 3 stays open.

Assistant media results (2026-11-08): still rendering, image/video frame extraction, vocabulary loading and value analysis now check the project again after awaited work before returning a result or adding an image event. The video-frame cache includes the project ID and document URL, preventing an asset ID in the next project from reusing its predecessor’s decoder. Proposal validation also checks the project by default after asynchronous registry work. A delayed-still test confirms that the old result does not appear in the new conversation. Other assistant session state and host paths remain to audit, so step 3 stays open.

Assistant turn project switch (2026-11-08): the conversation consumer now subscribes to the project ID and document URL for the duration of a turn. A switch aborts the active request immediately; any late event is discarded before updating chat or a proposal. Its finalizer clears buffered old words and releases turn state without saving or notifying on behalf of the new project. A delayed proposal test switches projects before the event arrives and confirms that the new chat and proposal remain untouched. Server-side cancellation and remaining host paths still require audit.

Assistant prompt preparation (2026-11-08): the request generator now pins the project before route/model discovery and attachment processing. Brief and film-plan reads use that captured ID, then check the project and abort signal before a model request. Scene-plan rereads and saves use the same identity, and a direct / tool result no longer records an old project’s note after navigation. A delayed brief-read test confirms no model turn starts with old project text after a switch. Remaining companion and server cancellation behavior still needs end-to-end coverage.

Project name and pack offers (2026-11-08): a project rename now applies the API response to editor state only if its opening project is still active. Leaving for the project list after saving also checks the starting project before navigating. The installed-pack update scan reads module manifests with a pinned project ID, ignores stale results after navigation, and hides an old project’s offers immediately. A delayed rename test confirms that the second project’s manifest, document and title remain intact. Further editor UI paths remain to audit.

Media relink and thumbnail switch (2026-11-08): relinking missing media now pins the opening project’s paths before hashing candidate files, checks that identity around each upload, and refuses to reload a later project’s preview. A delayed-write test verifies that the upload targets the old project and no reload reaches the new one. Thumbnail generation also pins its project across rendering, file write and manifest update; the per-project refresh interval resets on navigation. An in-flight write may leave an unreferenced file in the old project. Further editor UI paths remain to audit.

Assistant text read budget (2026-11-08): the built-in read_file now uses the same streamed 8 MiB project-text reader as plugin tools. It cancels a response that advertises an oversized body before buffering it, and still checks the project after the read. A test confirms the oversized response is refused. Other host-side data and graphics budgets remain open in step 4.

Assistant transcript budget (2026-11-08): transcript JSON loaded for assistant tools now passes through a streamed 8 MiB limit before parsing. An oversized advertised response is cancelled; a test confirms it is refused before JSON decoding. The project identity is still checked after loading. Other media and graphics budgets remain open in step 4.

Tool file capability paths (2026-11-08): the trusted tool context now validates readText and fileUrl paths against the project format before constructing a URL or fetching. It rejects traversal, absolute URLs and fragments even if a caller bypasses the sandbox bridge’s path check. A test confirms that a traversal read sends no request. Other asset URL and external capabilities remain under step 3 review.

Tool asset URL containment (2026-11-08): the trusted tool context now resolves an asset against its captured document URL and grants only a URL under that project’s root or a same-origin Blob, matching the sandbox host’s asset rule. An asset naming /api/private or a sibling project’s folder is rejected before a trusted tool can fetch it; a normal project asset still resolves. This covers a direct tool context path, while other asset and external capabilities remain under step 3 review.

Isolated graph sampling (2026-11-08): the graph editor now requests bounded batches of evaluated property samples from the opaque worker when isolation is enabled. It uses those values for the modified curve and its range without evaluating project expressions in the page. The host and worker limit addresses, sample times and total cells, and the host checks the response shape. Failed sampling leaves the modified curve unavailable with a visible explanation. Protocol tests exercise a real expression and input limits; a UI test confirms the modified curve uses worker samples. Viewport, retouch, audio and other editor mirrors still need worker-backed values, so step 2 stays open.

Isolated assistant value (2026-11-08): the assistant’s evaluate tool now sends isolated projects to the same worker evaluator used by the Inspector, after transferring the document, modules and loaded data. It does not run the project’s expression in the page. Tests verify the returned expression value and reject a value completed after a project switch. Viewport, retouch, audio and other editor mirrors still keep step 2 open.

Isolated viewport geometry (2026-11-08): hit testing and selection handles now use bounded batches of evaluated layers from the opaque worker when isolation is enabled, including parent transforms, masks and node properties. A delayed result is tied to the document, time, composition and project, and a worker error leaves selection geometry unavailable with a visible explanation. Protocol tests exercise a real expression and batch limits; a UI test draws selection from worker samples. Retouch, audio and other mirrors still keep step 2 open.

Inspector worker project switch (2026-11-08): the inspector’s isolated property read now pins the project before loading module declarations and refuses to start or display an evaluation after navigating to another project. Its pending result also includes the project ID and document URL. A UI test delays declaration until after navigation and confirms that the former project’s value is never requested. Other editor reads still require the same audit under step 3.

Isolated retouch placement (2026-11-08): the area-selection layer list now asks the opaque worker to place the composition, including nested compositions and instances, rather than running sampleAt on the trusted page. Its response is bounded to 4,096 plain layer records and checked by the host. Drawing waits for the placed result before proposing layers; a project, document, composition or time change rejects a stale result. Review boxes refresh asynchronously and failures are explained. Protocol tests exercise a real expression and invalid time; an editor test rejects a late result after navigation. Other mirror evaluation and default isolation keep step 2 open.

Isolated mask placement (2026-11-08): adding a mask in the inspector now obtains the layer’s evaluated properties from the worker before choosing its starting rectangle. It refuses a stale project, document, composition or time and explains a worker failure instead of silently creating a default mask from an expression it could not read. A UI test confirms the worker request. Other inspector and authoring mirrors remain under step 2.

Isolated sound bed values (2026-11-08): the sound effects tool now obtains the existing music or ambience gain and low-cut values from bounded worker samples before writing stop or build keyframes when isolation is active. It refuses a missing preview, worker failure or project switch instead of evaluating the project’s expression on the page. A focused test verifies that the worker-supplied values shape the keys without executing the expression locally. The audit also found local cue sampling and layer-clock evaluation in sound.ts, and layer-clock and rectangle geometry evaluation in tracking.ts; those mirror paths still keep step 2 open.

Isolated tracking rectangle (2026-11-08): when a track starts from a drawn rectangle, its evaluated size and the transforms of that rectangle, its parents and the video now come from a bounded worker layer sample. A project switch rejects the delayed result; errors do not fall back to page-side geometry. A focused test confirms the picture box uses worker values. The track and callout tools still use local layer-clock evaluation, and sound cues still use local sampling, so step 2 remains open.

Isolated sound cues (2026-11-08): cue sampling for sound placement, music planning and mix checks now runs in the opaque project worker when isolation is enabled. The protocol bounds and validates the returned cue list, and the editor refuses a result completed after a project switch. A worker protocol test covers the cue response; an editor test confirms the sound tool reads worker cues instead of sampling locally. The sound and tracking tools still evaluate layer clocks locally, so step 2 remains open.

Isolated media clocks (2026-11-08): sound beat and shot placement, tracking windows, tracked-frame captions and callout spans now request bounded file/composition time mappings from the project worker. The bridge sends only plain arrays and clock settings, validates the response, limits total samples and refuses a delayed result after a project switch. A protocol test uses an expression-driven speed; tool tests confirm that sound and callout placement use sampled moments. Tracking computes the mappings before writing its track file, so a worker failure does not leave that file behind. Other editor mirrors and path coverage keep step 2 open.

Isolated stabilization span (2026-11-08): the stabilize tool now obtains the video layer’s first and last file times through that same worker clock mapping, including expression-driven speed. Its media decoding still runs on the trusted side, while the project’s evaluation remains isolated. A focused test covers the sampled span. Other authoring mirrors and path coverage keep step 2 open.

Isolated mix motion (2026-11-08): the waveform/spectrogram image of the mix now gets the picture-motion curve from the project worker instead of sampling the expression-bearing composition on the editor page. The host validates the returned times and motion values, including a 16,384-sample limit; a worker protocol test and an editor test cover the response. Other authoring mirrors and execution paths keep step 2 open.

Isolated component framing (2026-11-08): making a component now derives its frame from worker-placed layers across the composition when isolation is active. The editor refuses more than 512 sampled instants or a delayed result from another project instead of evaluating the component’s expressions on the page. A focused test confirms that the worker’s animated boxes determine the component frame; the existing component test still covers ordinary local projects. Other authoring mirrors and execution paths keep step 2 open.

Isolated motion figures (2026-11-08): the motion-strip tool now asks the project worker for the six largest animated-property figures instead of evaluating expressions on the page after rendering its stills. The host validates the time span and every numeric figure, and a delayed answer is refused after a project switch. Protocol and editor tests cover an expression-driven radius. The tool’s separate picture rendering still follows its existing isolated path; other authoring mirrors keep step 2 open.

Isolated pin corners (2026-11-08): the pin tool now obtains evaluated target corners in bounded batches from the project worker when isolation is active. The host validates all four finite corners and rejects a changed project before returning the keys. A worker protocol test covers expression-driven target size and the batch limit; a tool test confirms the sampled corners set the pin keys. Push-in camera framing and other authoring mirrors still keep step 2 open.

Isolated push framing (2026-11-08): the push-in tool now reads the target quad, placed text sizes and the initial camera zoom and pan from the project worker when isolation is active. It checks project identity after each awaited response and refuses an invalid camera value. A tool test uses worker values for an expression-bearing target and camera; the existing framing tests still cover local projects. Other authoring mirrors and default isolation keep step 2 open.

Isolated critic entrances (2026-11-08): the critic’s visual evidence now selects noticeable layer entrances from bounded project-worker placement samples when isolation is active. A delayed sample is refused after a project switch, and an expression-bearing layer test confirms the entrance is chosen without evaluating it on the page. Other critic checks and scene-form reads still need worker-backed values, so step 2 remains open.

Isolated scene forms (2026-11-08): the composition check now classifies each scene from bounded worker-placed layers when isolation is active, including whether evaluated text is present. The host validates the plain text-presence flag, and a delayed placement refuses a project switch. A focused test confirms that repeated expression-bearing interface scenes are reported from worker samples. Other review checks and default isolation keep step 2 open.

Isolated quality checks (2026-11-08): the editor’s composition check, critic evidence and short-form first read now run built-in and project checks in the opaque project worker for isolated documents. The worker limits a composition to 4,096 quarter-second samples and 4,096 issues; the host validates issue fields and an 8 MiB response budget. Analysis JSON is included in the document snapshot, and delayed results refuse a project switch. Protocol tests exercise a real expression and reject a malformed issue; an editor test confirms worker issues reach the check caller. Default isolation, vector checks and other execution paths keep step 2 open.

Import without Worker (2026-11-08): accepting a plugin archive when no isolated worker exists now stops with a clear error. The importer no longer imports that plugin module into the trusted page as a fallback. A regression test accepts an archive while Worker is unavailable and confirms that its module side effect never runs. Browser and desktop import-path coverage remains open under step 2.

Iframe message validation (2026-11-08): the editor now checks the shape and count of plugin-load URLs before remapping them from the iframe transport. Malformed loaded and loadFailed envelopes reach the protocol validator, which closes the worker, instead of throwing while handling a browser message. Startup failures also bound their explanation. A browser-transport test dispatches a malformed response and confirms that the editor handler does not throw. Other bridge payload and native-message paths remain under step 3.

Module URL retention (2026-11-08): the browser host now drops each temporary data-URL mapping as soon as the worker answers a module load, successfully or with an error. Stopping the host also releases outstanding mappings, cached font-byte promises and queued messages. Repeated edits of a project module no longer leave all earlier encoded sources in the host’s memory. Aggregate browser and GPU memory still needs measurement before step 4’s resource box can close.

Encoded bridge paths (2026-11-08): the project-file bridge now refuses percent-encoded paths, URL query or fragment markers, colons and control characters before calling read or write capabilities. This closes encoded dot-segment and separator forms of traversal, plus ambiguous Windows stream and URL suffix paths, at the host boundary. Protocol tests confirm those requests never reach the project’s file callbacks. Other capability and cross-project checks remain under step 3.

Decoded resource roots (2026-11-08): the host now checks a plugin module or font URL against the project folder after repeated percent decoding and path normalization. Encoded separators, dot segments, backslashes and malformed escapes cannot make a same-origin URL appear to be in the project before the server interprets it. A focused test covers single and double encoding, foreign origins and valid encoded spaces. Browser fetch and server routing tests, plus other capabilities, remain under step 3.

Tool context encoded paths (2026-11-09): built-in editor tools now use that decoded resource-root guard for asset URLs and refuse percent-encoded file paths before reading, writing or returning a file URL. A context test checks encoded traversal against each operation and confirms it is rejected. Remaining asset and file entry points still need an end-to-end cross-project audit under step 3.

Assistant file commands (2026-11-09): read_file and write_file, plus their shared bounded text reader, now reject percent-encoded paths before issuing a project request. A focused test confirms neither fetch nor write starts for an encoded parent segment. Other project file entry points and server routing remain under step 3.

Plugin asset scope (2026-11-09): the editor’s plugin tool context now lists, reads and returns URLs only for validated files under assets/. A document asset cannot point that capability at project conversations or metadata. A focused test checks the filtered listing and refuses conversation reads and URLs before fetch. Broader capability and server-routing checks remain under step 3.

Transcription asset scope (2026-11-09): reading a transcript or starting media transcription now validates the asset path and decoded URL against the open project’s assets/ folder before opening the file. Focused tests refuse private API URLs, sibling-project paths and encoded traversal without issuing a fetch. Other editor media reads and end-to-end cross-project checks remain under step 3.

Assistant media frames (2026-11-09): media_frame now checks image and video asset paths against the current project’s assets/ folder before opening an image or decoder. A focused test refuses private API URLs, sibling projects and encoded traversal for both media types before fetch. Other direct editor media readers remain under step 3.

Track media placement (2026-11-09): adding a video layer or placing video and audio on a track now validates the media URL against the open project’s asset folder before probing duration or sound. The video-layer test refuses private routes, sibling projects and encoded traversal before the duration probe. Other direct editor media readers remain under step 3.

Source monitor fallback (2026-11-09): opening a source now validates its asset URL before using the renderer’s media URL or the browser’s fallback URL. An invalid source shows an error without creating a video or audio element; a UI test covers a private API URL. Other direct editor media readers remain under step 3.

Timeline sound sync (2026-11-09): the timeline’s clip synchronization now supplies only validated project asset URLs to the audio decoder, matching the assistant tool’s existing context guard. A focused test puts a private API URL in a video asset and confirms no decode begins. Other direct editor media readers remain under step 3.

Inspector asset previews (2026-11-09): sequence drawing thumbnails in the Inspector now use the validated project asset URL helper and leave an invalid image source empty. A UI test confirms that a document asset pointing to a private API route produces no such image URL. Other direct editor media readers remain under step 3.

Timeline sync project switch (2026-11-09): after sound analysis, the timeline sync command now checks the captured project, document URL and composition before applying operations. A delayed-result test switches projects during analysis and confirms that the new document receives no old edit. Other delayed editor operations still need the step 3 audit.

Media placement project switch (2026-11-09): adding a video layer, opening a source range and placing media on a track or in a new sequence now discard delayed duration and sound results after a project or composition change. Focused tests switch projects during each type of probe and confirm that no layer or sequence is added to the new document. Other delayed editor operations remain under step 3.

Media search transcripts (2026-11-09): the media panel now keeps its transcript text cache for the open project and document URL only, ignores reads completed after navigation and reads only validated assets/ transcript paths. A UI test opens two projects with the same transcript path and confirms that the old words never appear in the new project’s search. Other delayed editor reads remain under step 3.

Direction panel project scope (2026-11-09): delayed brief, plan and source-list reads no longer update the panel after a project switch; saving a brief checks the project again after reading and writing before adding its document asset. Plan targets and source thumbnails are validated asset paths before rendering. UI tests cover an old plan reply, a delayed brief write and a target path with traversal. Other delayed editor reads and writes remain under step 3.

Media bin and tag naming (2026-11-09): an open naming field now remembers its project and document URL. After navigation it is hidden, and even an old field event cannot tag or move an asset in the new project. A UI test presses Enter on the former field after a project switch and confirms no edit reaches the new document. Other editor-owned pending actions remain under step 3.

Filler review asset path (2026-11-09): the filler-cut review panel now checks that its list is a validated file under the current project’s assets before reading it. A UI test gives the list an escaping path and confirms that no file request starts. Other document-supplied media paths remain under step 3.

Version storage paths (2026-11-09): the project format now admits the editor’s versions/*.json snapshots and index, which storage previously refused. The UI filters index entries to version snapshot paths before a read, restore or deletion. Format, archive, storage-contract and editor tests cover valid snapshots and forged paths. Version creation and restore still require end-to-end testing; step 3 remains open.

Malformed file URL encoding (2026-11-09): the storage route now rejects malformed percent encoding in project file URLs with HTTP 400 before invoking any bucket operation. The shared storage contract checks this for in-memory, personal IndexedDB and folder storage; the remaining end-to-end routing audit stays under step 3.

Library name encoding (2026-11-09): plugin and sound library names now decode once through a validated path, reject malformed escapes with HTTP 400 and use the decoded name for the stored response’s MIME type. The shared storage contract checks malformed names in both shelves and an encoded valid sound name. Other API and cross-project capability routes remain under step 3.

Provider name encoding (2026-11-09): the LLM route now refuses a malformed encoded provider segment with HTTP 400 before selecting a provider or making any upstream request. A route test confirms no provider fetch. Provider grants and other API capabilities remain under step 3.

Editor file URL guard (2026-11-09): the editor’s common file URL builder and multipart upload entry now reject paths outside the project format before issuing a request. A focused test covers read, write and upload refusals for parent traversal and URL-like paths while preserving document, chat and version files. The server still validates paths independently; cross-project and document-supplied URLs remain under step 3.

Vector and CLI checks (2026-11-07): isolated browser SVG/Lottie export now reports that expression-bearing projects need raster export. CLI export, check-export and check refuse such expressions before native vector conversion or picture checks. Tests exercise all three CLI commands and the browser export’s early refusal. Worker-backed vector values and checks remain open.

Editor module transfer (2026-11-07): when isolated preview is enabled, the editor’s preview, stills, raster export and thumbnail now load every project module through the bounded opaque host before drawing. This includes Free code modules that are not listed as plugins. Reloads and document changes refresh the worker’s module list. The editor setting is still opt-in, and browser coverage of these paths remains before step 2 can close.

Editor module edit reload (2026-11-07): when an isolated module asset is reloaded at the same URL, the preview now disposes its worker and clears declarations and retained pictures before loading that URL again. This prevents a saved JavaScript edit from leaving its previous code active. The editor still needs end-to-end browser coverage and isolation by default.

Startup queue bounds (2026-11-06): while the isolated frame starts, consecutive document snapshots are coalesced and the host stops at 128 queued messages. A project may load at most 64 distinct plugin modules in one host. A browser test holds the frame at startup and verifies that excess messages close it promptly. Overall message bytes, media copies and platform memory remain open in step 4.

Bounded resource reads (2026-11-06): approved project modules (1 MiB) and fonts (16 MiB) are now read through a bounded stream; the host cancels a response as soon as it exceeds its limit, without first buffering its whole body. A test uses a response that never finishes after crossing the module limit and verifies prompt cancellation. Other media and model transfers still need equivalent host capabilities and budgets.

Approved network response budget (2026-11-06): when a plugin has a specific network grant, its bridge response body is read with a 64 MiB ceiling and cancelled before forwarding if it exceeds that ceiling. A test uses an open response advertising an oversized body and verifies cancellation. This bound does not itself validate the grant; permission separation is recorded below.

Permission separation (2026-11-06): declarations and drawing may share the project worker, but tools and checks now run in a separate opaque worker per plugin ID and module URL. The trusted host selects that worker from its own registry entry; the plugin cannot choose another host in a message. Changing the module URL or project disposes the former worker. Browser tests show a second plugin’s forged request cannot invoke the first plugin’s active fetch grant and verify host replacement. Editor-shipped packs are transferred only under their pack identity. Other capability checks in step 3 remain open.

Canvas request bounds (2026-11-06): the host refuses malformed dimensions and draw or whole-frame requests above 8,192 pixels on either side, using the same per-side ceiling as the editor’s project-size control. Scale is checked before a worker message is sent. Per-layer graphics allocations, aggregate pixels and platform memory limits still keep step 4’s resource box open.

Worker canvas retention (2026-11-06): the isolated renderer now keeps at most two released full-frame canvases in its reuse pool; further released canvases are resized to zero rather than held for later frames. This bounds that cache, while simultaneous layer allocations, WebGL contexts and actual browser/GPU memory still need measurement and limits before step 4 is complete.

Failure recovery (2026-11-06): a failed project or installed plugin attachment is no longer cached as a successful attachment; the next attempt can load a repaired source. Storyboard stills now propagate plugin attachment failures and display their error instead of silently producing a picture with missing plugin tools. A complete safe retry/open-without-extension flow and preservation tests for unsaved work remain open in step 4.

Bridge answer budget (2026-11-06): host replies to a sandbox file, data, still or other capability request are checked against the 8 MiB nested-data budget before posting; an oversized reply is refused to that call. Approved network replies retain their separate 64 MiB streamed-body ceiling. Tests cover both sides of this distinction. Media transfers still need their own budgets, so step 4’s resource box stays open.

Outbound message budget (2026-11-06): tool, check, draw, render and document messages are refused before the host sends more than 64 MiB of nested data or 10,000 entries. The browser transport checks again after it adds approved font bytes. A test verifies that an oversized tool input and document snapshot do not reach the worker. Transferred image/video bitmap allocations and aggregate graphics work remain outside this plain-data bound, so step 4 stays open.

A user opens, plays, edits and exports a .tramme project without granting its scripts the editor’s rights. Ordinary animation code needs no general execution permission. Extra capabilities, such as sending a media file to an external service, require a specific, understandable permission.

This work extends plugin isolation and the evaluator in the sandbox. It closes the isolation item in the plugins roadmap; enabling sandboxPreview alone does not close it.

  • apps/editor/src/importer.ts inventories plugins and expressions and asks before running imported code. Keep this question until the release gate below passes.
  • apps/editor/src/plugins/ runs tools, checks and drawing in workers hosted by an opaque-origin iframe with a network-denying CSP. Whole-frame evaluation and rendering also exist, behind a setting that is off by default.
  • The iframe and its worker cannot reach the editor’s origin as their own origin; guardRealm also narrows globals inside the worker. Desktop webviews, all execution paths and the independent review still need proof before the boundary is considered complete.
  • Expressions use new Function with selected global names shadowed. A blocked-name list is not a security boundary. Expressions must be covered even when a project has no plugins, including any mirror evaluator used by the interface.
  • Import validation, thumbnails, stills, vector exports, browser exports, the desktop app and the CLI must obey the same boundary. A sandboxed preview does not make an earlier native or page-side import safe.

The platform distinction matters: workers can use network and storage APIs. An opaque-origin sandbox or a dedicated origin without the editor’s credentials provides a boundary the host can enforce. Merely replacing globals does not.

  • Build and prove the runtime boundary on the supported browsers and desktop webviews. Decided (2026-11-05): an opaque-origin sandboxed iframe (sandbox="allow-scripts", never allow-same-origin) whose document is served with a Content-Security-Policy that denies the network, hosting the worker for computation and rendering. It needs no domain and serves the web, the desktop app and the CLI’s page alike. A dedicated credential-free origin (like the key vault’s) is the fallback only if a supported webview fails the proof. Preserve OffscreenCanvas/WebGL where supported; document compatibility before committing to the transport. What only a device can show (WebView2 on Windows, WKWebView on macOS) is written under the box as “to check on a device”, and does not block it.
  • Deny direct access to the editor’s DOM, cookies, IndexedDB, caches, other projects, account data, provider routes and keys. On desktop, expose no Tauri IPC, native commands or filesystem rights to project code. On the CLI, execute no untrusted plugin in the native Node process.
  • Deny direct network requests and remote module loading by platform policy, including alternative transports and nested execution contexts. Transfer approved code, media, fonts and model resources through the host; do not pass authenticated editor URLs as a substitute for isolation.

Done when: code running at module initialization cannot read the editor’s data or call its API, before any drawing or tool call occurs. Test the actual deployed headers and native protocol, not only mocked globals.

  • Move all imported plugins, expressions, modifiers, effects, simulations, checks and tools behind the boundary, including expression-only projects and the interface’s mirror evaluation.
  • Use that boundary during archive validation, import, project opening, thumbnails, playback, scrubbing, stills, raster/vector exports and CLI rendering. Pass data and finished pictures across it, never executable plugin callbacks.
  • Make isolated execution the default after validation. A missing capability, failed worker or unsupported platform must stop the affected operation with a clear explanation; never fall back silently to the editor’s or Node’s full rights.

Done when: a project cannot select an unprotected path through its contents, saved preferences, a query parameter or a failed isolated render.

Step 3. Give scripts only the capabilities they need

Section titled “Step 3. Give scripts only the capabilities they need”
  • Limit the host API to explicit operations on the current project: read approved assets, receive document data, draw, and propose validated, undoable edits. Expose neither arbitrary API forwarding nor unrestricted file paths.
  • Validate message kinds, payloads, paths, sizes, call lifetime and results on the host. Establish the caller’s project and permissions on the host; do not trust an identity claimed in a message.
  • Keep different permission sets separate. One plugin must not impersonate a plugin with approved network access, reuse its active call, or inherit its grants merely because both run in one project worker.
  • Keep provider keys on the trusted side. An approved external action names the service, operation and data; scripts never receive the key itself.

Done when: malformed, forged or replayed messages cannot access another project, broaden a capability or bypass the normal proposal validation.

  • Add deadlines to loading, checks, tool calls and rendering. The host can terminate and recreate a non-responsive worker; cancellation must not depend on the script cooperating.
  • Bound input sizes, archive expansion, messages, pending requests, canvas dimensions and graphics allocations. Enforce the resource limits available on each platform and state any limits the platform cannot enforce, rather than promising a hard memory cap it does not provide.
  • Preserve the user’s saved project and unsaved editor work after a script crashes, loops forever or exceeds a budget. Explain which operation stopped and offer a safe retry or opening without that extension.

Done when: a faulty project cannot freeze the editor’s main thread or trigger unbounded host-side work through its bridge.

Section titled “Step 5. Replace general consent with specific permissions”
  • After all other gates pass, remove the general “Run this project’s code?” question for ordinary isolated opening, playback and export. Do not describe this documentation release as having removed it.
  • Ask only for extra capabilities: a named external destination, files outside the project, or a paid provider action. Say what will happen, for example “Send this image to this service?”, rather than asking for JavaScript execution.
  • Scope remembered grants to the relevant project/plugin and capability; show and revoke them in settings. New destinations or broader permissions need a new decision. An old general trust answer must not become unrestricted access in the new model.

Done when: ordinary projects open without a code question, while an ungranted external or privileged action remains blocked and understandable.

  • Run adversarial tests for module-load side effects, expression escapes, cross-project reads/writes, authenticated requests, storage access, remote imports, alternate network APIs, Tauri/Node access, forged messages, permission confusion, infinite loops and oversized inputs. Verify rejection without an unprotected fallback.
  • Run the real import → reopen → preview → still → export paths on the web, Windows/WebView2, macOS/WKWebView, Linux and the CLI where supported. Cover private/personal storage modes and cloud mode when it exists; mark unsupported paths explicitly.
  • Compare preview and export against representative projects: video, transparency, 3D, simulations, expressions, modifiers, effects, installed plugins and vector output. Record understood pixel differences and measure frame time, memory and responsiveness on real hardware.
  • Obtain an independent security review of the boundary, bridge and native integration, fix its material findings, and record the tested versions/platforms and residual limitations.

The general permission disappears only after the enforced boundary, complete path coverage, capability checks, failure handling and adversarial/device tests pass. Until then, keep the existing warning and mark this work as unfinished. A worker, a signature, a blocklist or a default-setting change alone is not sufficient.