stillmade-sdk 0.1.42 → 0.1.43

package/packages/block-platform/project-type-starters.js

@@ -1,58 +1,20 @@
-import {REVENUE_REVIEW_STARTERS} from './revenue-review-starters.js';
 import {CURRENT_BUILTIN_TYPES,WORKSPACE_BLOCKS} from './catalog.js';
 
-// The motion starters (Motion Graphics, Product Launch Video, Screenshot to Motion, Product Photo Ad) carry the
-// Motion Designer packages, 4.2 MB of source each. They live in motion-starters.js so this module, imported at
-// startup for the Empty starter, stays small (November 2, 2026: they were 8.5 MB of the 17 MB the studio parsed
-// before Home showed). newProjectTypeFromStarter takes them as its third argument; loadProjectTypeStarter loads
-// them when one is chosen; project-type-starters-full.js is the sync form for Node.
-export const MOTION_STARTER_IDS=Object.freeze(['motion-graphics','saas-launch','screenshot-motion','product-photo-ad']);
-// The fixture Types (fixture-starters.js: the revenue-review Types, Product Ad Variants, the photo reels) embed exact
-// Block releases too; they resolve the same way, by id, for the acceptance drivers.
-export const FIXTURE_STARTER_IDS=Object.freeze([...REVENUE_REVIEW_STARTERS.map(item=>item.id),'product-ad-variants','property-listing-reel','product-promo-reel']);
-export const ON_DEMAND_STARTER_IDS=Object.freeze([...MOTION_STARTER_IDS,...FIXTURE_STARTER_IDS]);
+// November 4, 2026 (owner): the Motion starters (Motion Graphics, Product Launch Video, Screenshot to Motion, Product
+// Photo Ad) and their Motion Designer packages were deleted. No starter loads Blocks on demand any more; the names
+// stay so a later on-demand starter plugs in the same way.
+export const MOTION_STARTER_IDS=Object.freeze([]);
+export const ON_DEMAND_STARTER_IDS=Object.freeze([...MOTION_STARTER_IDS]);
 
 // These are editable starting configurations of the existing production Blocks,
 // not separate generators or new marketplace identities.
-// October 20, 2026 (owner): the revenue-review, ad-variant and photo-reel starters are off the
-// Create page; their definitions stay as acceptance fixtures, so newProjectTypeFromStarter still
-// resolves them by id for those drivers and for the creator experiments.
+// November 4, 2026 (owner): the Guided-style video starters, the revenue-review, ad-variant and photo-reel
+// fixtures and the Blocks they used (Script Writer, Shots, Blueprint and the rest) were deleted.
 export const PROJECT_TYPE_STARTERS=Object.freeze([
- {id:'faceless-youtube',name:'Faceless YouTube',description:'Write a narrated story, plan the visuals, and assemble a complete video.',blocks:['script','voiceover','shot-plan','blueprint','pipeline','editor'],brief:'Create a faceless YouTube video. Start with a clear hook, develop the story with concrete visual beats, and end with a useful conclusion. Ask for the topic, audience, target duration and sources. Do not invent factual claims.'},
- {id:'short-form',name:'Short-form vertical',description:'Build a concise story with a strong opening and visuals for a vertical screen.',blocks:['script','voiceover','shot-plan','pipeline','editor'],brief:'Create a short-form vertical video. Ask for the subject and intended platform. Keep narration concise, place the hook immediately, and plan readable 9:16 compositions with room for captions. Confirm the target length before writing.'},
- {id:'ai-commercial',name:'AI commercial',description:'Develop a campaign idea, maintain its visual direction, and edit the final spot.',blocks:['script','voiceover','shot-plan','blueprint','pipeline','editor'],brief:'Develop an AI commercial from the supplied campaign brief. Establish the audience, promise, tone, product proof and call to action. Ask for brand assets and target duration. Use only supported product claims; preserve a consistent visual direction.'},
- {id:'anime-episode',name:'Anime episode',description:'Develop the episode, cast and locations, then produce its shots and final cut.',blocks:['script','voiceover','blueprint','shot-plan','pipeline','editor'],brief:'Develop an anime episode with clear scene progression and character motivations. Ask for the premise, cast, intended duration and visual references. Prepare dialogue that can be reviewed for voice production. Maintain existing character and location references in Blueprint and Canvas.'},
- {id:'product-ad',name:'Product ad',description:'Show a product’s value with a focused script, visual proof and a clear call to action.',blocks:['script','voiceover','shot-plan','blueprint','pipeline','editor'],brief:'Create a product advertisement using supplied product facts and assets. Ask for the audience, channel, duration and call to action. Lead with a concrete customer problem, demonstrate verified features and benefits, and avoid invented testimonials, statistics or prices.'},
- {id:'music-video',name:'Music video',description:'Bring your track, plan a visual sequence, and cut the images and clips to the music.',blocks:['blueprint','shot-plan','pipeline','editor']},
- {id:'documentary',name:'Documentary',description:'Research and write the story, organize its visual references, and build the film.',blocks:['script','voiceover','blueprint','shot-plan','pipeline','editor'],brief:'Develop a documentary from the supplied subject and sources. Separate verified facts, attributed statements and open questions. Ask about the intended audience, length and available footage. Structure an evidence-based narrative and identify the visuals required for each section.'},
  {id:'empty',name:'Empty',description:'Start with protected Chat and add the Blocks your workflow needs.',blocks:[]},
- {id:'motion-graphics',name:'Motion Graphics',description:'Direct an idea, approve styleframes, and build editable coded motion scenes and a finished export.'},
- {id:'saas-launch',name:'Product Launch Video',description:'Turn product evidence and real UI into approved styleframes, an editable coded launch video, and a finished export.'},
- {id:'screenshot-motion',name:'Screenshot to Motion',description:'Turn exact product screenshots into an editable motion walkthrough without inventing product behavior.'},
- {id:'product-photo-ad',name:'Product Photo Ad',description:'Turn rights-cleared product photos and verified offer facts into an editable short advertisement.'},
 ]);
 
-// Business hypotheses stay separate from the reusable workflow definitions.
-// Selecting one prepares a private experiment draft; it never publishes,
-// spends credits, or upgrades its demand evidence label.
-export const REVENUE_LOOP_CANDIDATES=Object.freeze([
- ['captioned-business-clip','Service owners and consultants with an unposted recording','Finish a selected recording with accurate captions and personal first-project help.'],
- ['customer-story-clip','Businesses with an authorized customer interview','Preserve a real customer quote and finish a captioned excerpt.'],
- ['product-demonstration-clip','Small brands with real demonstration footage','Show the actual product in use with approved copy and a clear next step.'],
- ['farewell-story','Teams with already-collected farewell messages','Assemble supplied memories and messages into a reviewed farewell video.'],
- ['birthday-story','Gift buyers with collected photos and messages','Make a personal birthday story from their supplied memories.'],
- ['anniversary-story','Couples with supplied photos and messages','Arrange real memories and exact dedications into a short anniversary story.'],
- ['single-release-teaser','Artists with finished audio and cover artwork','Finish a short release visual using the original track and artwork.'],
- ['lyric-excerpt','Artists with approved lyrics and phrase timings','Create a short lyric visual with the exact supplied song and text.'],
-].map(([id,buyer,job],index)=>{
- const starter=REVENUE_REVIEW_STARTERS.find(item=>item.id===id);
- return {id,starterId:id,rank:index+1,name:starter.name,buyer,job,promise:starter.description,evidence:'hypothesis',
-  hypothesis:'A reviewed output and bounded first-project help can earn a genuine external payment. Demand and acquisition cost remain unverified.',
-  primaryMetric:'Paid and delivered customer orders',
-  decisionRule:'Approve the representative result and verify payment and export before acquisition. Test one offer within the agreed budget. Gift and music purchases need an explicit decision on one-project versus recurring payment.'};
-}));
-
-// `onDemand` holds the loaded definitions of motion and fixture starters by id (MOTION_STARTERS, FIXTURE_STARTERS).
+// `onDemand` holds the loaded definitions of on-demand starters by id.
 export function newProjectTypeFromStarter(starter,id,onDemand=null){
  const selected=PROJECT_TYPE_STARTERS.find(item=>item.id===starter);
  if(ON_DEMAND_STARTER_IDS.includes(starter)){
@@ -61,23 +23,21 @@ export function newProjectTypeFromStarter(starter,id,onDemand=null){
   return {...structuredClone(definition),id};
  }
  if(!selected){
-  const base=structuredClone(CURRENT_BUILTIN_TYPES.find(type=>type.legacyMode==='guided')||CURRENT_BUILTIN_TYPES[0]);
+  const base=structuredClone(CURRENT_BUILTIN_TYPES.find(type=>type.legacyMode==='blank')||CURRENT_BUILTIN_TYPES[0]);
   return {...base,id,name:'Untitled Project Type',version:'0.1.0',description:'A production workflow you can customize.'};
  }
  const stages=selected.blocks.map(key=>{
   const block=WORKSPACE_BLOCKS.find(item=>item.manifest.id==='sm.'+key);
   if(!block)throw Error('The '+key+' production Block is unavailable.');
-  return {id:key,blockId:block.manifest.id,version:block.manifest.version,label:block.manifest.name,...key==='script'&&selected.brief?{config:{input:{schemaVersion:1,topic:selected.brief}}}:{}};
+  return {id:key,blockId:block.manifest.id,version:block.manifest.version,label:block.manifest.name};
  });
  return {schemaVersion:1,id,version:'0.1.0',name:selected.name,description:selected.description,license:'MIT',startingChat:'native',stages,
-  ...(selected.id!=='empty'?{defaults:{aspectRatio:['short-form','product-ad'].includes(selected.id)?'9:16':'16:9'},onboarding:[{id:'audience',label:'Who is this for?',type:'text'},{id:'tone',label:'What tone fits?',type:'select',options:['Clear and direct','Playful','Cinematic','Documentary']}]}:{}),
-  connections:stages.some(step=>step.id==='script')&&stages.some(step=>step.id==='voiceover')?[{from:{stage:'script',port:'output'},to:{stage:'voiceover',port:'input'}}]:[],
+  ...(selected.id!=='empty'?{defaults:{aspectRatio:'16:9'},onboarding:[{id:'audience',label:'Who is this for?',type:'text'},{id:'tone',label:'What tone fits?',type:'select',options:['Clear and direct','Playful','Cinematic','Documentary']}]}:{}),
+  connections:[],
   summary:{text:selected.description,origin:'llm',generation:'build-time',generator:'Codex',status:'ready'}};
 }
 
-// Resolve any starter, loading the motion starters' packages first when one of them is chosen.
+// Resolve any starter.
 export async function loadProjectTypeStarter(starter,id){
- if(MOTION_STARTER_IDS.includes(starter))return newProjectTypeFromStarter(starter,id,(await import('./motion-starters.js')).MOTION_STARTERS);
- if(FIXTURE_STARTER_IDS.includes(starter))return newProjectTypeFromStarter(starter,id,(await import('./fixture-starters.js')).FIXTURE_STARTERS);
  return newProjectTypeFromStarter(starter,id);
 }

package/packages/block-platform/script-handoff.js

@@ -1,5 +1,4 @@
 import {assert} from '../block-sdk/contracts.js';
-import {isScriptWriterHandoff} from './script-writer.js';
 import {packageForStage} from './stage-package.js';
 
 const SDK_SCRIPT_RUNTIMES = new Set(['recipe', 'javascript', 'capability']);
@@ -14,14 +13,13 @@ export function resolveScriptHandoff(from, to, edge, pinnedManifest) {
       to.blockId !== 'sm.voiceover' || !VOICEOVER_VERSIONS.has(to.version) ||
       edge.to.port !== 'input' || Object.hasOwn(edge, 'adapter')) return null;
 
-  const builtin = isScriptWriterHandoff(from, to, edge);
-  if (!builtin && (pinnedManifest?.id !== from.blockId || pinnedManifest.version !== from.version ||
+  if ((pinnedManifest?.id !== from.blockId || pinnedManifest.version !== from.version ||
       !SDK_SCRIPT_RUNTIMES.has(pinnedManifest.runtime) ||
       !Object.hasOwn(pinnedManifest.outputs || {}, edge.from.port) ||
       pinnedManifest.outputs[edge.from.port]?.type !== 'script')) return null;
 
   return {
-    kind: builtin ? 'script-writer' : 'sdk',
+    kind: 'sdk',
     sourceStageId: from.id, sourcePort: edge.from.port,
     targetStageId: to.id, targetPort: edge.to.port,
     blockId: from.blockId, version: from.version,

package/packages/block-platform/type-workspace.js

@@ -80,6 +80,8 @@ export async function compileTypeWorkspace(type,{experimentalBrowser,experimenta
   });
   return { definition, digest: await digest(definition), canvas: { nodes, edges }, activeStage: definition.stages.find(stage=>stage.enabled !== false)?.id || null };
 }
+// A test fixture many tests assert on (its stage ids and order), not a model Type: its Export video Step beside the
+// Editor breaks the builder contract ("One job per Step"). The create-type scaffold (TYPE_SCAFFOLD) is the model.
 export const RECIPE_TYPE_EXAMPLE = {
   schemaVersion: 1, id: 'example.text-workflow', version: '1.0.0', name: 'Text workflow',
   description: 'Clean text through two connected blocks, then use the shared editor to assemble media.',

package/packages/block-sdk/appearance.js

@@ -10,7 +10,9 @@ export const APPEARANCE_TOKENS = Object.freeze([
  '--signal','--signal-dim','--signal-glow','--accent','--accent-hover','--accent-dim','--accent-glow','--accent-contrast',
  '--bg-primary','--bg-secondary','--bg-tertiary','--bg-elevated','--bg-hover','--border','--border-light',
  '--text-primary','--text-secondary','--text-muted','--success','--warning','--danger','--shadow','--shadow-lg','--shadow-1','--shadow-2',
- '--editor-standout-bg','--editor-standout-fg'
+ '--editor-standout-bg','--editor-standout-fg',
+ // The Block kit's see-through page background, for words over a photo (block-kit.css, November 3, 2026).
+ '--scrim'
 ]);
 const tokens = new Set(APPEARANCE_TOKENS);
 const colorProperty = /^(?:color|background(?:-color|-image)?|(?:border|outline)(?:-(?:top|right|bottom|left|inline|block|inline-start|inline-end|block-start|block-end))?(?:-color)?|(?:box|text)-shadow|fill|stroke|caret-color|accent-color|text-decoration(?:-color)?|column-rule(?:-color)?|-webkit-text-fill-color)$/;

package/packages/block-sdk/block-tier.js

@@ -7,7 +7,7 @@
 //   extension   an Editor tool (editor-extension)
 //   glue        the parts any project may use between Steps (When, Only new items, AI write, Import media)
 export const BLOCK_TIERS=Object.freeze(['app','job','ingredient','extension','glue']);
-const GLUE=new Set(['sm.when','sm.new-items','sm.continue-if','sm.connect-app','sm.ai-write','sm.ai-decide','sm.write-summary','sm.import-media']);
+const GLUE=new Set(['sm.when','sm.connect-app','sm.ai-write','sm.ai-decide','sm.write-summary','sm.import-media']);
 const hostedOperations=manifest=>(manifest?.permissions?.capabilities||[]).filter(name=>name!=='connection.execute'&&name!=='comfyui.execute');
 
 /** The tier of a Block, from its manifest. */

package/packages/block-sdk/builder-contract.js

@@ -47,9 +47,11 @@ const SECTIONS=Object.freeze([
  // on module Blocks and refused a job that needs one).
  rule('runtime-choice','block',null,
   'Pick the runtime from the job. No hosted AI: a recipe or isolated `javascript`, both able to run unattended. One text, script or brief prompt returning text, script or JSON: a `capability` Block. Hosted operations on other values (a transcript, media, structured data), several hosted operations in a row, or a result shaped in code: one `module` Block, `module/main.js` calling `stillmade.hosted.run(operation, request)` for each operation in `permissions.capabilities` (MODULES.md), never one Block per operation; it runs in the person\'s browser while StillMade is open. Build a new Block in a folder with `stillmade-block create`, `test`, `ready` and `pack`, and import the file `pack` writes (a module Block writes `<id>-<version>.stillmade-module.json`) through Create, then Import Block. A `.stillmade-block` archive is only for adapting a GitHub repository.'),
+ // November 3, 2026 (owner, "Yes, one page"): a guided job is one Block on one page, its cheap check before the
+ // expensive run on that page too; a workspace (CAD, the Editor) stays its own Step, and using what it made is the next.
  rule('block-scope','both',
-  'One Step per job: start one only where a person works with the result, where finding new items turns into handling each, or where the result leaves StillMade; all else is a part.',
-  'A Step is one job: the work between two moments where a person or the outside world must see the result. Start a new Step only at one of three points; everything else is a part of the neighboring Step.\n\n1. **A person works with the result**: reads, edits, picks or approves it (a workspace Block such as a script, a Canvas or an Editor, or an approval). So Bible, Canvas and Editor are separate Steps after Chat.\n2. **Finding new things turns into handling each one**: the trigger (a schedule or an app event), the app read, its filter and "only new" are the first job; what is done with each item is the next job. A trigger is a setting of the first job, never a Step of its own.\n3. **The result leaves StillMade**: it is sent, posted, published, paid or written into another app. Consecutive writes to the same app, with the glue that shapes data for them, are one job.\n\nIn a production the Steps are the workspaces a person opens: work feeding the next workspace is its part, else it joins the one before. A Block with its own interface (a workspace, editor or picker) is always its own Step; two such Steps are never one. A video ends in the Editor (1.0), which has captions and export built in, so Export video is never a Step beside it.\n\nA part that only runs in the desktop app cannot share a Step with cloud parts. Before adding a Step, name which of the three reasons makes it separate; if none applies, make it a part of a neighbor. A Step nobody would ever open must not exist on its own. Prefer an app task\'s own filter (a Gmail query such as `has:attachment filename:png`) to an AI check, and use AI decide only for judgement.\n\nBuild one Block for a job one Block can do: a module Block calls every hosted operation the job needs (it transcribes a sermon, then finds the verses said in it), a JavaScript Block does several local transforms, a workspace owns its whole document. A Block being built never takes an ingredient\'s result only so the ingredient can be its own part or Step (Transcribe in front of a verse finder): it calls that operation itself. Parts in one Step (`groups` in the Project Type) are for jobs made of Blocks that already exist and app tasks, each keeping its own permission, approval and credit rules. Never invent a combined runtime.\n\nExamples: "every new email with an image becomes a generated image" is two Steps, "Gmail · New emails with images" (When, fetch with an image filter, only new) and "Image from email" (AI write, Generate image); listing When, Fetch, Only new, AI decide, Continue only if, AI write and Generate image as seven Steps splits one job into its parts. "A new Meta lead goes to HubSpot" is three Steps: "Meta Ads · New leads", "Qualify lead" and "HubSpot · Add contact".'),
+  'One Step per job: a guided job is one Block whose page holds the inputs, a cheap check and the result. New Steps only for a workspace (CAD, Editor; using its work is the next Step), a one-time setup, a later render, a hand-off, handling each new item, or leaving StillMade.',
+  'A Step is one job: the work between two moments where a person or the outside world must see the result. A guided job, one the person fills in and then gets a result from, is one Step with one Block whose own screen holds everything: the inputs and settings, then a cheap check before the expensive run (the script and a voice sample before the video), then the result. On a wide screen the inputs sit on the left and the result\'s place on the right; on a phone they stack, the result\'s place under the button. A cheap check or a review the person does on that screen never starts a new Step. Start a new Step only at one of these points; everything else is a part of the neighboring Step.\n\n1. **A person works with the result**: in a workspace they spend a while in (the Editor, a storyboard, a Canvas, a CAD or drawing tool), or someone else approves or takes it over (a hand-off). Turning what a workspace made into something else is the next Step: a CAD tool is its own Step, and the Block that takes pictures of its model and makes a video is the next one. So Bible, Canvas and Editor are separate Steps after Chat.\n2. **Finding new things turns into handling each one**: the trigger (a schedule or an app event), the app read, its filter and "only new" are the first job; what is done with each item is the next job. A trigger is a setting of the first job, never a Step of its own.\n3. **The result leaves StillMade**: it is sent, posted, published, paid or written into another app. Consecutive writes to the same app, with the glue that shapes data for them, are one job.\n4. **Setup or a wait**: a one-time setup that is not part of each job (a brand kit, capturing a voice or a likeness), or a render that takes minutes and is delivered later.\n\nIn a production the Steps are the workspaces a person opens: work feeding the next workspace is its part, else it joins the one before. A Block with its own interface (a workspace, editor or picker) is always its own Step; two such Steps are never one. A Type whose own Block renders the finished video (`timeline.render`) needs no Editor Step; the Editor (1.0, captions and export built in) is a Step only when the person edits the cut by hand, and Export video is never a Step beside it.\n\nA part that only runs in the desktop app cannot share a Step with cloud parts. Before adding a Step, name which of these reasons makes it separate; if none applies, make it a part of a neighbor. A Step nobody would ever open must not exist on its own. Prefer an app task\'s own filter (a Gmail query such as `has:attachment filename:png`) to an AI check, and use AI decide only for judgement.\n\nBuild one Block for a job one Block can do: a module Block calls every hosted operation the job needs (it transcribes a sermon, then finds the verses said in it), a JavaScript Block does several local transforms, a workspace owns its whole document. A Block being built never takes an ingredient\'s result only so the ingredient can be its own part or Step (Transcribe in front of a verse finder): it calls that operation itself. Parts in one Step (`groups` in the Project Type) are for jobs made of Blocks that already exist and app tasks, each keeping its own permission, approval and credit rules. Never invent a combined runtime.\n\nExamples: "a listing video from my photos and the home\'s facts" is one Step: one Block whose page takes the photos and facts, shows the script and a voice sample to check, then makes the video. "every new email with an image becomes a generated image" is two Steps, "Gmail · New emails with images" (When, fetch with an image filter, only new) and "Image from email" (AI write, Generate image); listing When, Fetch, Only new, AI decide, Continue only if, AI write and Generate image as seven Steps splits one job into its parts. "A new Meta lead goes to HubSpot" is three Steps: "Meta Ads · New leads", "Qualify lead" and "HubSpot · Add contact".'),
  rule('capability-contract','block',
   'Define the contract first: typed inputs (optional with safe defaults where possible), outputs, state, permissions, UI, failures and cancellation. Keep the interface small; keep the job whole.',
   'Translate the request into an explicit capability contract before implementation: what the Block does; each input with its type, meaning and whether it is required (prefer optional settings with safe defaults over extra required questions); each output with its type and meaning; persistent state; project context it reads; permissions; UI; long-running behavior; expected failures; cancellation; determinism; and whether it needs hosted models, media, desktop tools or shared editing. Keep the public interface as small and general as possible (few required inputs, one primary output) and keep implementation details out of it; small means a small interface, never a fragment of a job. A Block that generates images, video or speech declares only its prompt and output: every Step that runs it gets the host’s generation settings (model, quality, length and resolution, voice, speed, how many), saved with the Step, changed on its page or by Chat, and shown with their cost before each run.'),
@@ -71,7 +73,7 @@ const SECTIONS=Object.freeze([
  // November 2, 2026 (owner): a sermon Block's video input read "Video"; it should read "Drop your sermon video here".
  rule('input-words','block',
   'Name each input in the job\'s words (`sermonVideo`, not `video`): StillMade words its drop area from the name.',
-  'Name each input for what the person brings, in the job\'s words: `sermonVideo` for a sermon clip Block, `listingPhotos` for a listing, `lessonSlides` for a lesson podcast. StillMade titles the input from that name ("Sermon video") and words its drop area from it ("Drop your sermon video here", the formats, "Choose a video"), in StillMade and the SDK preview, so never draw your own upload box for an input. Keep a bare type name (`video`, `file`) only when any file of that kind does the job. The `description` says what makes a good one.'),
+  'Name each input for what the person brings, in the job\'s words: `sermonVideo` for a sermon clip Block, `listingPhotos` for a listing, `lessonSlides` for a lesson podcast. StillMade titles the input from that name ("Sermon video") and words its drop area from it ("Drop your sermon video here", the formats, "Choose a video"), in StillMade and the SDK preview, so never draw your own upload box or `<input type="file">`: a Block\'s screen shows the files as tiles and adds more with `<button class="sm-add" data-stillmade-add="listingPhotos" aria-label="Add photos">`, which opens StillMade\'s picker and upload, and a list\'s tiles drop or reorder a file with `data-stillmade-remove="listingPhotos" data-index="2"` and `data-stillmade-move="listingPhotos" data-index="2" data-to="1"` buttons; the files arrive through `onInput`. Keep a bare type name (`video`, `file`) only when any file of that kind does the job. The `description` says what makes a good one.'),
  // November 2, 2026 (owner): every screen speaks the job, as a product made only for it would, and stays quiet. The same
  // day (owner, of four tiles each saying "Only on the device it was added from"): "if it's a notification make it a
  // notification": state is one StillMade notification or nothing, never a sentence on the page or one per item.
@@ -84,17 +86,17 @@ const SECTIONS=Object.freeze([
  // pictures its full-screen button; a video without controls stays the Block's own. Also that day (owner: "there is no
  // separation and I cannot tell what is going on"): a pick is the kit's ink fill, and media that cannot show is a quiet tile.
  rule('ui','block',
-  'Prefer `manifest.ui`; custom views use the Block kit (`sm-*`) unless a look is named. Pictures over words: preview each option before choosing; few words, fold the rest; buttons carry `data-stillmade-action`; the start button names the action (never "Run" or "Make it") and shows no price (StillMade adds it). A job fits one screen unscrolled and a 320px phone; an app (editor, configurator, CAD tool) works like that app: full canvas, panels, tools, undo, never a form. An app puts `data-stillmade-layout="own"` on its root: StillMade never centers or zooms it. `<video controls>` gets StillMade\'s player; leave out `controls` when the Block drives playback. A pick keeps the kit\'s ink fill; media that cannot show is a wordless `sm-media-off` tile.',
-  'If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction needs one. Build custom views from the Block kit the host injects (`block-kit.css`): the result in `sm-stage`, picks as pictures in `sm-choices`, the picked one in the kit\'s ink fill (never restyled to an outline, a tint or the page\'s background) so it reads at a glance, one solid `sm-primary` naming the action in the job\'s words ("Plan the tour", "Generate voiceover"; never "Run" or "Make it") and no price (StillMade\'s run button adds it), extras in a closed `sm-more`; a look the person names wins. Fit one laptop screen without scrolling: label beside control, status in a few words, files as tiles, rare tools as icons, (i) on unclear controls. These compact rules are for a job or an ingredient. Size the view to the Block\'s tier (block-tier.js): an app, a workspace a person works in for a while (video editor, 3D configurator, CAD or drawing tool), looks and works like that kind of app instead of a compact page: its canvas or stage fills the view, with the panels, toolbars, inspector or timeline such an app has, direct manipulation (select, drag, zoom), keyboard shortcuts and undo; it keeps the host appearance and Block kit controls, its panels may scroll, and on a phone its tools fold into sheets while the canvas stays usable. Never shrink an app into a form of fields and one button. StillMade centers a standard view narrower than its Step and zooms a view to fill its space; an app that lays itself out (full-size canvas or WebGL, its own scroll, pan or zoom, its own Ctrl/Cmd +/- keys) puts `data-stillmade-layout="own"` on its outermost element, and StillMade then never centers, zooms or takes those keys. StillMade draws one player for every `<video controls>` (play, timeline, time, sound and full screen, shown while the pointer is on the video, with keys and touch) and a full-screen button on result pictures in `sm-stage` or `sm-gallery` and on any element marked `data-stillmade-expand` (the same value makes one set of pictures, `off` removes it); `data-stillmade-player="native"` keeps the browser\'s controls, and a `<video>` without `controls` is the Block\'s own and is never touched. A picture or clip that cannot show here (kept on another device, or it did not open) keeps its place as a quiet `sm-media-off` tile in its own shape with the `image-off` glyph and the reason in its label, never words in its place. Drop words nobody needs; put helpful ones in a closed `sm-hint`. Mark each button `data-stillmade-action="what it does"` and label each field: Chat presses and fills them. Expose the capability, not the implementation: sensible defaults, previews, progress, clear errors, visible outputs. Show no raw JSON, internal IDs, filesystem details, provider terms or developer settings unless the Block is a developer tool. When a person chooses among options they need to hear or see (voices, music, fonts, looks, templates, images), let them preview each option before choosing: a sample or thumbnail from the Block\'s own files or the host\'s free samples, never a paid generation. Skip previews only when there is nothing to preview. Choices StillMade owns (voices, models in the run review) already show samples. Follow the host appearance (Light, Dark and White) and one elastic layout: stacked on a 320px phone with no sideways scroll (result first, action pinned), and from 860px the controls left (≤380px), the result filling the right. Short settings sit side by side, each label beside its control (`sm-field`, `sm-settings`; three or four short options as one `data-segmented` row); many items are one line each (`sm-list`) that open in place; input files are small tiles (`sm-gallery data-size="small"`); on a phone chip rows scroll sideways and long lists show three. Compacting moves controls, never deletes them.'),
+  'Prefer `manifest.ui`; custom views use the Block kit (`sm-*`) unless a look is named. Pictures over words: preview each option before choosing; few words, fold the rest; buttons carry `data-stillmade-action`; the start button names the action (never "Run" or "Make it") and shows no price (StillMade adds it). A job fits one screen unscrolled and a 320px phone; an app (editor, configurator, CAD tool) works like that app: full canvas, panels, tools, undo, never a form. An app puts `data-stillmade-layout="own"` on its root: StillMade never centers or zooms it. `<video controls>` gets StillMade\'s player; leave out `controls` when the Block drives playback. A pick keeps the kit\'s ink fill; media that cannot show is a wordless `sm-media-off` tile. Every part shows at once: the result\'s place is drawn before the first run in its own shape and size, so nothing pops in; on wide screens inputs sit left and the result right; on phones they stack, the result under the button.',
+  'If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction needs one. Build custom views from the Block kit the host injects (`block-kit.css`): the result in `sm-stage`, drawn before the first run in the shape and size of what is coming (`data-ratio="9:16"` for a vertical clip, lines for text, a player bar for sound) so every part of the screen is in place at once and the result fills a place the person already sees instead of popping in somewhere unexpected; StillMade draws it the same way on the Steps it draws; on a wide screen what goes in sits on the left and the result on the right, side by side, and they stack only on narrow screens and phones, the result\'s place under the button, picks as pictures in `sm-choices`, the picked one in the kit\'s ink fill (never restyled to an outline, a tint or the page\'s background) so it reads at a glance, one solid `sm-primary` naming the action in the job\'s words ("Plan the tour", "Generate voiceover"; never "Run" or "Make it") and no price (StillMade\'s run button adds it), extras in a closed `sm-more`; a look the person names wins. Fit one laptop screen without scrolling: label beside control, status in a few words, files as tiles, rare tools as icons, (i) on unclear controls. These compact rules are for a job or an ingredient. Size the view to the Block\'s tier (block-tier.js): an app, a workspace a person works in for a while (video editor, 3D configurator, CAD or drawing tool), looks and works like that kind of app instead of a compact page: its canvas or stage fills the view, with the panels, toolbars, inspector or timeline such an app has, direct manipulation (select, drag, zoom), keyboard shortcuts and undo; it keeps the host appearance and Block kit controls, its panels may scroll, and on a phone its tools fold into sheets while the canvas stays usable. Never shrink an app into a form of fields and one button. StillMade centers a standard view narrower than its Step and zooms a view to fill its space; an app that lays itself out (full-size canvas or WebGL, its own scroll, pan or zoom, its own Ctrl/Cmd +/- keys) puts `data-stillmade-layout="own"` on its outermost element, and StillMade then never centers, zooms or takes those keys. StillMade draws one player for every `<video controls>` (play, timeline, time, sound and full screen, shown while the pointer is on the video, with keys and touch) and a full-screen button on result pictures in `sm-stage` or `sm-gallery` and on any element marked `data-stillmade-expand` (the same value makes one set of pictures, `off` removes it); `data-stillmade-player="native"` keeps the browser\'s controls, and a `<video>` without `controls` is the Block\'s own and is never touched. A picture or clip that cannot show here (kept on another device, or it did not open) keeps its place as a quiet `sm-media-off` tile in its own shape with the `image-off` glyph and the reason in its label, never words in its place. Drop words nobody needs; put helpful ones in a closed `sm-hint`. Mark each button `data-stillmade-action` (`run` on the one that runs the Block, which the device checks press once; a page that checks first keeps `run` on that button for both presses; what it does on the others, `"play sample"`) and label each field: Chat presses and fills them. Expose the capability, not the implementation: sensible defaults, previews, progress, clear errors, visible outputs. Show no raw JSON, internal IDs, filesystem details, provider terms or developer settings unless the Block is a developer tool. When a person chooses among options they need to hear or see (voices, music, fonts, looks, templates, images), let them preview each option before choosing: a sample or thumbnail from the Block\'s own files or the host\'s free samples, never a paid generation. Skip previews only when there is nothing to preview. Choices StillMade owns (voices, models in the run review) already show samples. Follow the host appearance (Light, Dark and White) and one elastic layout: stacked on a 320px phone with no sideways scroll (the inputs, the button in normal flow, never pinned, then the result\'s place under it), and from 860px the controls left (≤380px), the result filling the right. Short settings sit side by side, each label beside its control (`sm-field`, `sm-settings`; three or four short options as one `data-segmented` row); many items are one line each (`sm-list`) that open in place; input files are small tiles (`sm-gallery data-size="small"`); on a phone chip rows scroll sideways and long lists show three. Compacting moves controls, never deletes them.'),
  rule('multiplayer','block',
   'Custom views share edits: `StillMade.onShared`, publish every editable field (`data-stillmade-share`, `bindShared`, `updateShared`), respect `canEdit`, never re-run on remote updates.',
   'Projects are multiplayer. A custom view subscribes through `StillMade.onShared(callback)` and publishes every editable field: give static controls a unique `id` and `data-stillmade-share="field"` (the host owns their synchronization), use `StillMade.bindShared(field, elementId)` for controls created dynamically, and `StillMade.updateShared(values, before, options)` for structured values; private variables and DOM values are not shared. Mark a truly device-only control (playback, hover, device selection) with `data-stillmade-local`. Observe shared outputs as well as state, honor `canEdit` in every mutating callback (read-only participants cannot write), never run, click or call a paid integration in response to a remote update, and preserve conflicting drafts. Shared background work uses `sharedWork` with the `work.shared` permission.'),
  rule('external-services','block',
   'External services only via hosted operations or `connection.execute`; the host owns providers, keys, BYOK, credits and consent.',
-  'Reach external services only through StillMade\'s hosted operations, the connections service (`connection.execute`), or, in a module Block, `stillmade.net.fetch` to origins declared in `permissions.network` (with the key each needs), `stillmade.net.connect` for a live WebSocket to one of them, and `stillmade.connections.call` to adapters or catalog apps in `permissions.connections`; never put keys in code, inputs or headers: StillMade adds each person\'s own key on its servers. The host owns the model and provider choice, BYOK keys, StillMade credits, spending consent, authorization, token refresh, rate limits, retries and provider errors; a Block never receives a secret and never names a provider unless it must. Treat provider unavailability, timeout, cancellation and partial failure as typed outcomes the Block reports, not crashes. Generated images, video, voices, music and sound effects come from hosted operations or the `media.generate` action, paid with the user\'s StillMade credits at StillMade\'s prices; for structured model output declare a `json` output with `capability.schema` instead of parsing prose. When a Block needs npm libraries, WebAssembly (threaded: `"threads": true` in module.json) or heavy compute, use `runtime: "module"` and reach hosted operations through `stillmade.hosted.run` with the operations listed in `permissions.capabilities`. Decode, cut, join, re-encode, extract or normalise audio and video with `stillmade.media.transform` on the device; never ask for a server render. For a rich interactive interface (React or another framework, SVG, canvas, drag), use a frame view: `src/view.config.json` with `{"runtime":"frame"}` and `src/view.js` bundled as one IIFE, colored with StillMade\'s theme variables. For files and structured data use the `file`, `document`, `table`, `url`, `date` and `color` types and their generated controls and presentations, not JSON text.'),
+  'Reach external services only through StillMade\'s hosted operations, the connections service (`connection.execute`), or, in a module Block, `stillmade.net.fetch` to origins declared in `permissions.network` (with the key each needs), `stillmade.net.connect` for a live WebSocket to one of them, and `stillmade.connections.call` to adapters or catalog apps in `permissions.connections`; never put keys in code, inputs or headers: StillMade adds each person\'s own key on its servers. The host owns the model and provider choice, BYOK keys, StillMade credits, spending consent, authorization, token refresh, rate limits, retries and provider errors; a Block never receives a secret and never names a provider unless it must. Treat provider unavailability, timeout, cancellation and partial failure as outcomes the Block reports, not crashes: a call the result needs throws and fails the run (see Useful failures); an optional part\'s failure is caught, given its fallback and named in an optional `notes` text output. Generated images, video, voices, music and sound effects come from hosted operations or the `media.generate` action, paid with the user\'s StillMade credits at StillMade\'s prices; for structured model output declare a `json` output with `capability.schema` instead of parsing prose. When a Block needs npm libraries, WebAssembly (threaded: `"threads": true` in module.json) or heavy compute, use `runtime: "module"` and reach hosted operations through `stillmade.hosted.run` with the operations listed in `permissions.capabilities`. Decode, cut, join, re-encode, extract or normalise audio and video with `stillmade.media.transform` on the device; never ask for a server render. For a rich interactive interface (React or another framework, SVG, canvas, drag), use a frame view: `src/view.config.json` with `{"runtime":"frame"}` and `src/view.js` bundled as one IIFE, colored with StillMade\'s theme variables. For files and structured data use the `file`, `document`, `table`, `url`, `date` and `color` types and their generated controls and presentations, not JSON text.'),
  rule('dependencies','block',
-  'No npm or system dependencies; inline small licensed code and record its license and notice in the manifest.',
-  'A Block must declare everything it requires and must not assume anything is installed. Portable packages carry no package dependencies (`portable.dependencies` is empty): inline small, license-compatible code and record its license and notice in `manifest.license` and `manifest.provenance`. Desktop-only tools are reached solely through declared desktop permissions and the host desktop bridge. If a dependency cannot be delivered through the Block runtime, report the incompatibility instead of assuming the user\'s machine has it.'),
+  'No npm or system dependencies; inline small licensed code and record its license and notice in the manifest; the person is the copyright holder.',
+  'A Block must declare everything it requires and must not assume anything is installed. Portable packages carry no package dependencies (`portable.dependencies` is empty): inline small, license-compatible code and record its license and notice in `manifest.license` and `manifest.provenance`. The copyright holder in the Block\'s own `provenance.notice` is the person it is made for: replace the placeholder `create` writes with their name, never StillMade, the SDK or yourself. Desktop-only tools are reached solely through declared desktop permissions and the host desktop bridge. If a dependency cannot be delivered through the Block runtime, report the incompatibility instead of assuming the user\'s machine has it.'),
  rule('security','both',
   'Treat inputs, files and responses as untrusted; request minimum permissions; never leak secrets in outputs, state, errors or UI.',
   'Treat Block code, external data, files, repositories, model output and network responses as untrusted. Request the minimum permissions and capabilities; `stillmade-block permissions --fix` declares exactly what the source uses. Do not weaken the sandbox (QuickJS has no fetch, DOM, timers, modules or Node APIs). Validate and bound every value crossing a boundary. Never expose secrets through logs, outputs, project context, UI, error messages or serialized state.'),

package/packages/block-sdk/capabilities.js

@@ -187,7 +187,7 @@ export function validateCapability(capability,manifest){
   assert(frames.length<2||capability.firstFrame.$input!==capability.lastFrame.$input,'CAPABILITY_BINDING','Use different image inputs for the first and last frame');
   assert(!own(capability,'lastFrame')||own(capability,'firstFrame'),'CAPABILITY_BINDING','A last frame needs a first frame');
   assert(Object.values(manifest.inputs).filter(port=>port.type==='image').length===frames.length,'CAPABILITY_BINDING','Bind every image input as the first or last frame');
-  if(own(capability,'settings')){const settings=videoSettings(capability.settings,{strict:true,firstFrame:own(capability,'firstFrame')});const entry=VIDEO_GENERATION_MODELS[settings.model];assert(!own(capability,'lastFrame')||entry.lastFrame,'CAPABILITY_SETTINGS',`${entry.label} does not accept a last frame`);}
+  if(own(capability,'settings')){const settings=videoSettings(capability.settings,{strict:true,firstFrame:own(capability,'firstFrame'),lastFrame:own(capability,'lastFrame')});const entry=VIDEO_GENERATION_MODELS[settings.model];assert(!own(capability,'lastFrame')||entry.lastFrame,'CAPABILITY_SETTINGS',`${entry.label} does not accept a last frame`);}
   generationText(capability);
   assert(typeof capability.output==='string'&&own(manifest.outputs,capability.output),'CAPABILITY_BINDING','Use the declared video output port');return true;
  }

package/packages/block-sdk/contracts.js

@@ -235,9 +235,11 @@ export function validateManifest(manifest, { builtIn = false } = {}) {
   check(plain(permissions), 'permissions', 'Declare permissions explicitly');
   for (const [key, scopes] of Object.entries(plain(permissions) ? permissions : {})) {
     check(['project', 'network', 'connections', 'filesystem', 'secrets', 'capabilities', 'actions', 'desktop'].includes(key), `permissions.${key}`, 'Unknown permission family');
-    // Network entries may be {origin, auth} objects; every other family is a string list.
+    // Network entries may be {origin, auth} objects; every other family is a string list. A module Block's empty
+    // capabilities list is the same as none (November 3, 2026: a module that only calls actions.run was refused for
+    // `capabilities: []` with a message about capability and ComfyUI Blocks).
     check(Array.isArray(scopes) && scopes.every(s => typeof s === 'string' || key === 'network' && plain(s)), `permissions.${key}`, 'Expected string array');
-    if (Array.isArray(scopes)) check(key === 'desktop' ? scopes.length<=DESKTOP_PERMISSIONS.length && new Set(scopes).size===scopes.length && scopes.every(s=>DESKTOP_PERMISSIONS.includes(s)) : key === 'project' ? scopes.every(s => SCOPES.includes(s)) : key === 'actions' ? ['javascript','module'].includes(manifest.runtime)&&scopes.length<=PORTABLE_ACTIONS.length&&new Set(scopes).size===scopes.length&&scopes.every(s=>PORTABLE_ACTIONS.includes(s)) : key === 'capabilities' ? (manifest.runtime === 'module' ? scopes.length >= 1 && scopes.length <= CAPABILITY_RUN_OPERATIONS.length && new Set(scopes).size === scopes.length && scopes.every(s => CAPABILITY_RUN_OPERATIONS.includes(s)) : scopes.length === 1 && (manifest.runtime === 'comfyui' && scopes[0] === 'comfyui.execute' || manifest.runtime === 'capability' && HOSTED_OPERATION_NAMES.includes(scopes[0]))) : key === 'network' && manifest.runtime === 'module' ? networkValid(scopes) : key === 'connections' ? manifest.runtime === 'module' && connectionsValid(scopes) : scopes.length === 0, `permissions.${key}`, key === 'connections' ? 'Unsupported permission: only module Blocks declare connections, up to 8 published adapters by app ID such as app:openapi:notion' : key === 'network' ? (manifest.runtime === 'module' ? `Declare network origins as https origins, optionally with {origin, auth}: ${networkProblem(scopes)}` : 'Unsupported permission: only module Blocks declare network origins; other runtimes reach services through hosted operations and connections') : key === 'capabilities' ? (['module','capability','comfyui'].includes(manifest.runtime) ? 'Declare each hosted operation once, from the supported list (a capability or ComfyUI Block declares exactly one)' : 'Unsupported permission: only capability, ComfyUI and module Blocks declare hosted operations. A javascript or recipe Block declares none: remove permissions.capabilities, or make the AI work its own capability Block') : 'Unsupported permission; Blocks have no ambient filesystem or secrets');
+    if (Array.isArray(scopes)) check(key === 'desktop' ? scopes.length<=DESKTOP_PERMISSIONS.length && new Set(scopes).size===scopes.length && scopes.every(s=>DESKTOP_PERMISSIONS.includes(s)) : key === 'project' ? scopes.every(s => SCOPES.includes(s)) : key === 'actions' ? ['javascript','module'].includes(manifest.runtime)&&scopes.length<=PORTABLE_ACTIONS.length&&new Set(scopes).size===scopes.length&&scopes.every(s=>PORTABLE_ACTIONS.includes(s)) : key === 'capabilities' ? (manifest.runtime === 'module' ? scopes.length <= CAPABILITY_RUN_OPERATIONS.length && new Set(scopes).size === scopes.length && scopes.every(s => CAPABILITY_RUN_OPERATIONS.includes(s)) : scopes.length === 1 && (manifest.runtime === 'comfyui' && scopes[0] === 'comfyui.execute' || manifest.runtime === 'capability' && HOSTED_OPERATION_NAMES.includes(scopes[0]))) : key === 'network' && manifest.runtime === 'module' ? networkValid(scopes) : key === 'connections' ? manifest.runtime === 'module' && connectionsValid(scopes) : scopes.length === 0, `permissions.${key}`, key === 'connections' ? 'Unsupported permission: only module Blocks declare connections, up to 8 published adapters by app ID such as app:openapi:notion' : key === 'network' ? (manifest.runtime === 'module' ? `Declare network origins as https origins, optionally with {origin, auth}: ${networkProblem(scopes)}` : 'Unsupported permission: only module Blocks declare network origins; other runtimes reach services through hosted operations and connections') : key === 'capabilities' ? (['module','capability','comfyui'].includes(manifest.runtime) ? 'Declare each hosted operation once, from the supported list (a capability or ComfyUI Block declares exactly one)' : 'Unsupported permission: only capability, ComfyUI and module Blocks declare hosted operations. A javascript or recipe Block declares none: remove permissions.capabilities, or make the AI work its own capability Block') : 'Unsupported permission; Blocks have no ambient filesystem or secrets');
   }
   if(Object.values(plain(manifest.outputs)?manifest.outputs:{}).some(port=>['workspace-edit','workspace-edit[]'].includes(port?.type))) {
     check(WORKSPACE_EDIT_FIELDS.some(field=>canProposeWorkspace(manifest,field)), 'permissions.project', 'Workspace edits require matching context.FIELD.read and workspace.FIELD.propose permissions');
@@ -257,6 +259,8 @@ export function validateManifest(manifest, { builtIn = false } = {}) {
         continue;
       }
       check(plain(c) && UI_INPUT_CONTROLS.includes(c.control) && Object.hasOwn(manifest.inputs || {}, c.port), 'ui', 'Control must bind to a declared input');
+      // A text input of several lines (one fact per line, a list) declares it, so every host draws a box that keeps its line breaks.
+      if (plain(c) && c.multiline !== undefined) check(c.multiline === true && c.control === 'text' && manifest.inputs?.[c.port]?.type === 'text', 'ui', 'multiline: true goes on a text control bound to a text input');
       if (plain(c) && Object.hasOwn(UI_CONTROL_TYPES, c.control)) check(UI_CONTROL_TYPES[c.control].includes(manifest.inputs?.[c.port]?.type), 'ui', `The ${c.control} control binds a ${UI_CONTROL_TYPES[c.control].join(', ')} input`);
       if (plain(c) && ['select','multiselect'].includes(c.control)) {
         check(manifest.inputs?.[c.port]?.type === (c.control === 'select' ? 'text' : 'text[]'), 'ui', 'Select binds text; multiselect binds text[]');

package/packages/block-sdk/first-party-identities.js

@@ -4,32 +4,6 @@
 export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.ai-decide@1.0.0",
  "sm.ai-write@1.0.0",
- "sm.animated-scene-assistant@1.0.0",
- "sm.animated-scene@2.0.0",
- "sm.animated-scene@2.1.0",
- "sm.animated-scene@2.2.0",
- "sm.animated-scene@2.3.0",
- "sm.animated-scene@2.3.1",
- "sm.animated-scene@2.3.2",
- "sm.animated-scene@2.3.3",
- "sm.animated-scene@2.3.4",
- "sm.animated-scene@2.3.5",
- "sm.animated-scene@2.3.6",
- "sm.animated-scene@2.3.7",
- "sm.animated-scene@2.3.8",
- "sm.animated-scene@2.3.9",
- "sm.blueprint-assistant@1.0.0",
- "sm.blueprint@2.0.0",
- "sm.blueprint@2.1.0",
- "sm.blueprint@2.1.1",
- "sm.blueprint@2.1.2",
- "sm.blueprint@2.1.3",
- "sm.blueprint@2.1.4",
- "sm.blueprint@2.1.5",
- "sm.blueprint@2.1.6",
- "sm.blueprint@2.1.7",
- "sm.blueprint@2.1.8",
- "sm.blueprint@2.1.9",
  "sm.board-editor@2.0.0",
  "sm.board-editor@2.1.0",
  "sm.board-editor@2.2.0",
@@ -47,19 +21,11 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.captions@2.0.0",
  "sm.character@2.0.0",
  "sm.character@2.0.1",
- "sm.chat@2.0.0",
- "sm.chat@2.0.1",
- "sm.chat@2.0.2",
- "sm.chat@2.0.3",
  "sm.compare@2.0.0",
  "sm.compare@2.0.1",
  "sm.compare@2.0.2",
  "sm.connect-app@1.0.0",
  "sm.contact-fields@1.0.0",
- "sm.continue-if@1.0.0",
- "sm.describe-media@2.0.0",
- "sm.describe-media@2.0.1",
- "sm.describe-media@2.1.0",
  "sm.edit-assistant@2.0.0",
  "sm.edit-assistant@2.0.1",
  "sm.edit-assistant@2.0.2",
@@ -92,8 +58,6 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.grade@2.0.0",
  "sm.grade@2.0.1",
  "sm.grade@2.0.2",
- "sm.image-editor@2.0.0",
- "sm.image-editor@2.0.1",
  "sm.import-media@2.0.0",
  "sm.import-media@2.0.1",
  "sm.import-media@2.0.2",
@@ -101,7 +65,6 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.location@2.0.1",
  "sm.meta-creative@1.0.0",
  "sm.motion-graphics@2.0.0",
- "sm.new-items@1.0.0",
  "sm.panel-strip@2.0.0",
  "sm.panel-strip@2.1.0",
  "sm.panel-strip@2.2.0",
@@ -118,7 +81,6 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.panel-strip@2.4.2",
  "sm.photo-notes@1.0.0",
  "sm.photo-notes@1.1.0",
- "sm.pick-photos@1.0.0",
  "sm.pipeline@2.0.0",
  "sm.pipeline@2.1.0",
  "sm.pipeline@2.2.0",
@@ -128,38 +90,12 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.pipeline@2.2.4",
  "sm.pipeline@2.2.5",
  "sm.pipeline@2.2.6",
- "sm.quality-audit@1.0.0",
- "sm.quality-audit@1.0.1",
- "sm.quality-audit@1.0.2",
- "sm.research@2.0.0",
- "sm.research@2.0.1",
- "sm.research@2.0.2",
  "sm.rough-cut@2.0.0",
  "sm.rough-cut@2.0.1",
  "sm.rough-cut@2.0.2",
  "sm.score@2.0.0",
- "sm.script@2.0.0",
- "sm.script@2.1.0",
- "sm.script@2.1.1",
- "sm.script@2.1.2",
- "sm.script@2.1.3",
- "sm.script@2.1.4",
- "sm.script@2.1.5",
- "sm.shot-plan-assistant@1.0.0",
- "sm.shot-plan@2.0.0",
- "sm.shot-plan@2.1.0",
- "sm.shot-plan@2.1.1",
- "sm.shot-plan@2.1.2",
- "sm.shot-plan@2.1.3",
- "sm.shot-plan@2.2.0",
- "sm.shot-plan@2.2.1",
- "sm.stock-search@2.0.0",
  "sm.style@2.0.0",
  "sm.style@2.0.1",
- "sm.thumbnail@2.0.0",
- "sm.thumbnail@2.0.1",
- "sm.transcribe@2.0.0",
- "sm.transcribe@2.0.1",
  "sm.transition@2.0.0",
  "sm.transition@2.0.1",
  "sm.transition@2.0.2",
@@ -179,26 +115,7 @@ export const FIRST_PARTY_SDK_IDENTITIES=Object.freeze(new Set([
  "sm.voiceover@2.1.6",
  "sm.when@1.0.0",
  "sm.when@1.1.0",
- "sm.whiteboard-assistant@1.0.0",
  "sm.write-summary@1.0.0",
- "sm.youtube@2.0.0",
- "stillmade.narration@1.0.0",
- "stillmade.narration@1.0.1",
- "stillmade.occasion-story@1.0.0",
- "stillmade.occasion-story@1.0.1",
- "stillmade.occasion-story@1.0.2",
- "stillmade.photo-reel-composer@1.0.0",
- "stillmade.photo-reel-composer@1.0.1",
- "stillmade.photo-reel-composer@1.0.2",
- "stillmade.product-ad-variants@1.0.0",
- "stillmade.release-visuals@1.0.0",
- "stillmade.release-visuals@1.0.1",
- "stillmade.release-visuals@1.0.2",
- "stillmade.screen-recorder@1.0.0",
- "stillmade.screen-recorder@1.0.1",
- "stillmade.short-form-finish@1.0.0",
- "stillmade.short-form-finish@1.0.1",
- "stillmade.short-form-finish@1.0.2",
- "stillmade.short-form-finish@1.0.3"
+ "stillmade.generate@1.0.0"
 ]));
 export const isFirstPartySdkIdentity=manifest=>FIRST_PARTY_SDK_IDENTITIES.has(`${manifest?.id}@${manifest?.version}`);