stillmade-sdk 0.1.47 → 0.1.48

package/packages/block-cli/workspace.js

@@ -0,0 +1,304 @@
+// A workspace: one folder holding several Blocks, the code they share and the workflows (Project Types) that join
+// them (owner, November 6, 2026: build several Blocks at once outside StillMade, in Claude Code, Codex or Cursor).
+//
+//   stillmade.workspace.json   {"schemaVersion":1,"name":"Listing kit","version":"1.0.0"}
+//   blocks/<name>/             one Block folder each (stillmade.block.json ...), the same layout `create` makes
+//   shared/                    code module Blocks import from src/main.js; `build` bundles it into each Block
+//   workflows/<name>.json      a Project Type whose Steps may name a Block by its folder ("block": "listing-facts")
+//
+// Every Block in it is still its own Block: it passes its own readiness gate and imports on its own.
+import {readFile,writeFile,mkdir,readdir,lstat} from 'node:fs/promises';
+import {join,resolve,dirname,relative,sep,basename} from 'node:path';
+import {createRequire} from 'node:module';
+import {fileURLToPath,pathToFileURL} from 'node:url';
+import {renderBuilderContract} from '../block-sdk/builder-contract.js';
+import {SDK_VERSION} from '../block-sdk/contracts.js';
+
+export const WORKSPACE_FILE='stillmade.workspace.json';
+export const BLOCKS_DIR='blocks',WORKFLOWS_DIR='workflows',SHARED_DIR='shared';
+export const WORKSPACE_STATE='.stillmade/workspace.json';
+const NAME=/^[a-z][a-z0-9-]{0,59}$/,VERSION=/^\d+\.\d+\.\d+$/;
+const usage=message=>Object.assign(new Error(message),{code:'USAGE'});
+const fail=(message,code='WORKSPACE')=>Object.assign(new Error(message),{code});
+const exists=async path=>{try{await lstat(path);return true;}catch(error){if(['ENOENT','ENOTDIR'].includes(error.code))return false;throw error;}};
+const json=value=>`${JSON.stringify(value,null,2)}\n`;
+const posix=path=>path.split(sep).join('/');
+
+export function workspaceConfig(value){
+ if(!value||typeof value!=='object'||Array.isArray(value)||value.schemaVersion!==1)throw fail(`${WORKSPACE_FILE} needs "schemaVersion": 1.`);
+ const extra=Object.keys(value).filter(key=>!['schemaVersion','name','version','description'].includes(key));
+ if(extra.length)throw fail(`${WORKSPACE_FILE} does not take ${extra.join(', ')}. It holds schemaVersion, name, version and description.`);
+ if(typeof value.name!=='string'||!value.name.trim()||value.name.length>80)throw fail(`${WORKSPACE_FILE}: name is the workspace's name, up to 80 characters.`);
+ if(typeof value.version!=='string'||!VERSION.test(value.version))throw fail(`${WORKSPACE_FILE}: version is three numbers, such as 1.0.0.`);
+ if(value.description!==undefined&&(typeof value.description!=='string'||value.description.length>500))throw fail(`${WORKSPACE_FILE}: description is up to 500 characters.`);
+ return value;
+}
+
+export async function isWorkspaceRoot(path){return exists(join(path,WORKSPACE_FILE));}
+
+/** The workspace holding path (a folder or a file in it), or null: {root, config}. */
+export async function findWorkspace(path){
+ let folder=resolve(path);
+ try{if(!(await lstat(folder)).isDirectory())folder=dirname(folder);}catch{folder=dirname(folder);}
+ for(let depth=0;depth<24;depth++){
+  let text=null;
+  try{text=await readFile(join(folder,WORKSPACE_FILE),'utf8');}catch(error){if(!['ENOENT','ENOTDIR'].includes(error.code))throw error;}
+  if(text!==null){let value;try{value=JSON.parse(text);}catch(error){throw fail(`${WORKSPACE_FILE}: ${error.message}`);}return {root:folder,config:workspaceConfig(value)};}
+  const up=dirname(folder);if(up===folder)return null;folder=up;
+ }
+ return null;
+}
+export async function requireWorkspace(path,command){
+ const found=await findWorkspace(path);
+ if(!found)throw usage(`${command} works inside a workspace. Start one with \`stillmade-block init <folder>\`, or use \`stillmade-block create <folder>\` for a single Block.`);
+ return found;
+}
+
+/** A name for a folder: lower case words joined by hyphens. */
+export function folderName(text){
+ const name=String(text||'').toLowerCase().replace(/[^a-z0-9]+/g,'-').replace(/^[^a-z]+|-+$/g,'').slice(0,60);
+ if(!NAME.test(name))throw usage(`Name the item with letters, such as price-drop-alert.`);
+ return name;
+}
+
+/** Everything in the workspace, in folder order. Never throws for one broken item; it carries a problem instead. */
+export async function workspaceItems(root){
+ const listing=async folder=>{try{return (await readdir(join(root,folder),{withFileTypes:true})).sort((a,b)=>a.name<b.name?-1:a.name>b.name?1:0);}catch(error){if(error.code==='ENOENT')return [];throw error;}};
+ const blocks=[],workflows=[],shared=[];
+ for(const entry of await listing(BLOCKS_DIR)){
+  if(!entry.isDirectory()||entry.name.startsWith('.'))continue;
+  const path=join(root,BLOCKS_DIR,entry.name);let manifest=null,problem=null;
+  try{manifest=JSON.parse(await readFile(join(path,'stillmade.block.json'),'utf8'));}
+  catch(error){if(error.code==='ENOENT')continue;problem=`stillmade.block.json: ${error.message}`;}
+  blocks.push({kind:'block',name:entry.name,path,manifest,problem,source:await exists(join(path,'src','main.js'))});
+ }
+ for(const entry of await listing(WORKFLOWS_DIR)){
+  // <name>.samples.json beside a workflow holds the inputs its preview runs with; it is not a workflow.
+  if(!entry.isFile()||!entry.name.endsWith('.json')||entry.name.endsWith('.samples.json'))continue;
+  const path=join(root,WORKFLOWS_DIR,entry.name);let type=null,problem=null;
+  try{type=JSON.parse(await readFile(path,'utf8'));}catch(error){problem=`${entry.name}: ${error.message}`;}
+  workflows.push({kind:'workflow',name:entry.name.slice(0,-5),path,type,problem});
+ }
+ const walk=async(folder,prefix)=>{for(const entry of await listing(folder)){if(entry.name.startsWith('.')||entry.name==='node_modules')continue;if(entry.isDirectory())await walk(`${folder}/${entry.name}`,`${prefix}${entry.name}/`);else if(entry.isFile())shared.push(`${prefix}${entry.name}`);}};
+ await walk(SHARED_DIR,'');
+ return {blocks,workflows,shared};
+}
+
+/** What a Block's kind reads as in the preview and the import list. */
+export function blockKind(manifest){
+ const permissions=manifest?.permissions||{};
+ if(Array.isArray(manifest?.triggers)&&manifest.triggers.length)return 'automation';
+ if((permissions.connections||[]).length||(permissions.capabilities||[]).includes('connection.execute'))return 'connector';
+ return 'block';
+}
+
+// --- Workflows ------------------------------------------------------------------------------------------------
+
+/**
+ * A workflow file as StillMade's Project Type: each Step that names a Block by folder ("block": "listing-facts")
+ * gets that Block's blockId and version, and the Block's folder joins packages, which the CLI then embeds.
+ */
+export async function compileWorkflow(type,{root,file}){
+ if(!Array.isArray(type?.stages)||!type.stages.some(stage=>stage&&typeof stage==='object'&&Object.hasOwn(stage,'block')))return type;
+ const where=file?posix(relative(root,file)):'The workflow',packages=[...(type.packages||[])],added=new Set();
+ const stages=[];
+ for(const stage of type.stages){
+  if(!stage||typeof stage!=='object'||!Object.hasOwn(stage,'block')){stages.push(stage);continue;}
+  const {block,...rest}=stage;
+  if(typeof block!=='string'||!NAME.test(block))throw fail(`${where}: Step ${stage.id||'?'} names block ${JSON.stringify(block)}. Give the folder name of a Block in ${BLOCKS_DIR}/.`);
+  if(rest.blockId!==undefined||rest.version!==undefined)throw fail(`${where}: Step ${stage.id||'?'} names both block and blockId. Keep "block" (the folder); the id and version come from that Block.`);
+  const folder=join(root,BLOCKS_DIR,block);let manifest;
+  try{manifest=JSON.parse(await readFile(join(folder,'stillmade.block.json'),'utf8'));}
+  catch(error){throw fail(error.code==='ENOENT'?`${where}: Step ${stage.id||'?'} names block "${block}", but ${BLOCKS_DIR}/${block} has no stillmade.block.json.`:`${BLOCKS_DIR}/${block}/stillmade.block.json: ${error.message}`);}
+  stages.push({...rest,blockId:manifest.id,version:manifest.version});
+  if(!added.has(folder)){added.add(folder);packages.push(folder);}
+ }
+ return {...type,stages,packages};
+}
+
+/** Each workspace Block's tests/mocks.json by id@version, so a workflow's checks and preview answer its hosted calls
+ *  the way the Block's own test does (a Type file carries no mocks). */
+export async function workspaceMocks(root){
+ const {blocks}=await workspaceItems(root),found=new Map();
+ for(const item of blocks){
+  if(!item.manifest?.id)continue;
+  let text;try{text=await readFile(join(item.path,'tests','mocks.json'),'utf8');}catch{continue;}
+  try{found.set(`${item.manifest.id}@${item.manifest.version}`,JSON.parse(text));}catch(error){throw fail(`${BLOCKS_DIR}/${item.name}/tests/mocks.json: ${error.message}`);}
+ }
+ return found;
+}
+
+const PORT_TYPES=port=>String(port?.type||'');
+/** Connections between consecutive Steps where an earlier Step's output has the same name, or the same meaning and type, as a later input. */
+export function suggestConnections(stages){
+ const connections=[];
+ for(let index=1;index<stages.length;index++){
+  const target=stages[index];
+  for(const [name,port] of Object.entries(target.manifest.inputs||{})){
+   let from=null;
+   for(let back=index-1;back>=0&&!from;back--){
+    const outputs=Object.entries(stages[back].manifest.outputs||{});
+    const match=outputs.find(([out])=>out===name)||outputs.find(([,out])=>out?.semantic&&out.semantic===port?.semantic&&PORT_TYPES(out)===PORT_TYPES(port));
+    if(match)from={stage:stages[back].id,port:match[0]};
+   }
+   if(from)connections.push({from,to:{stage:target.id,port:name}});
+  }
+ }
+ return connections;
+}
+
+/** workflows/<name>.json with a Step for each named Block (every Block when none are named), connected where the ports agree. */
+export async function addWorkflow(root,name,{blocks:names=[],config}){
+ const slug=folderName(name),file=join(root,WORKFLOWS_DIR,`${slug}.json`);
+ if(await exists(file))throw usage(`${WORKFLOWS_DIR}/${slug}.json already exists.`);
+ const {blocks}=await workspaceItems(root);
+ const chosen=names.length?names.map(block=>{const found=blocks.find(item=>item.name===block);if(!found)throw usage(`There is no Block folder ${BLOCKS_DIR}/${block}. The Blocks here: ${blocks.map(item=>item.name).join(', ')||'none yet'}.`);return found;}):blocks;
+ if(!chosen.length)throw usage(`Add a Block first (stillmade-block add <name>); a workflow is made of the workspace's Blocks.`);
+ const broken=chosen.find(item=>!item.manifest);if(broken)throw fail(`${BLOCKS_DIR}/${broken.name}: ${broken.problem}`);
+ const used=new Set(),stages=chosen.map(item=>{let id=item.name.split('-')[0];while(used.has(id))id=`${id}-${used.size+1}`;used.add(id);return {id,block:item.name,label:item.manifest.name,manifest:item.manifest};});
+ const readable=slug.replace(/-/g,' ');
+ const type={
+  schemaVersion:1,id:`creator.${slug}`,version:'1.0.0',name:readable[0].toUpperCase()+readable.slice(1),
+  description:`Replace with one sentence saying what ${readable} makes for the person.`,
+  stages:[...(config?.first?[config.first]:[]),...stages.map(({manifest,...stage})=>stage)],
+  connections:suggestConnections(stages),
+ };
+ await mkdir(dirname(file),{recursive:true});
+ await writeFile(file,json(type),{flag:'wx'});
+ return {created:file,kind:'workflow',steps:type.stages.map(stage=>stage.block||stage.blockId),connections:type.connections.length,
+  next:'Connect any other output to an input by hand in "connections": {"from":{"stage":"<Step id>","port":"<output>"},"to":{"stage":"<Step id>","port":"<input>"}}, replace the placeholder description, then run `stillmade-block test` from the workspace folder.'};
+}
+
+// --- Shared code ----------------------------------------------------------------------------------------------
+
+/** esbuild from the workspace's own install (`npm install` adds it), else from beside the SDK. */
+export async function loadBundler(root){
+ for(const base of [join(root,'package.json'),fileURLToPath(import.meta.url)]){
+  try{const path=createRequire(base).resolve('esbuild');return await import(pathToFileURL(path).href);}catch{}
+ }
+ return null;
+}
+const IMPORTS=/(?:^|[;\n}])\s*(?:import\s*[\w{*'"]|export\s[^;'"]*?from\s*['"])|\bimport\s*\(/;
+const BANNER='// Built by `stillmade-block build` from src/main.js and the workspace\'s shared/ code. Edit those files, not this one.';
+
+/**
+ * Bundles src/main.js of every module Block that has one (with what it imports from shared/) into its
+ * module/ entry, writing only files that changed. Returns {built, unchanged, failed, shared}: shared maps each
+ * Block to the shared/ files it uses. bundler: an esbuild-compatible {build}; found in the workspace by default.
+ */
+export async function buildWorkspace(root,{only,bundler}={}){
+ const {blocks}=await workspaceItems(root),targets=blocks.filter(item=>item.source&&item.manifest?.runtime==='module'&&(!only||only.includes(item.name)));
+ const report={built:[],unchanged:[],failed:[],shared:{}};
+ if(!targets.length)return report;
+ bundler??=await loadBundler(root);
+ for(const item of targets){
+  let entry='main.js';
+  try{entry=JSON.parse(await readFile(join(item.path,'module.json'),'utf8')).entry||entry;}catch(error){if(error.code!=='ENOENT'){report.failed.push({block:item.name,message:`module.json: ${error.message}`});continue;}}
+  const output=join(item.path,'module',entry);
+  // Code that imports nothing needs no bundler: it is the module as it is.
+  if(!bundler){
+   let text;try{text=await readFile(join(item.path,'src','main.js'),'utf8');}catch(error){report.failed.push({block:item.name,message:`src/main.js: ${error.message}`});continue;}
+   if(IMPORTS.test(text)){report.failed.push({block:item.name,message:'src/main.js imports other files. Install the workspace\'s tools once with `npm install` (it adds esbuild, which joins them into the Block), then build again.'});continue;}
+   report.shared[item.name]=[];
+   let current=null;try{current=await readFile(output,'utf8');}catch{}
+   if(current===text){report.unchanged.push(item.name);continue;}
+   await mkdir(dirname(output),{recursive:true});await writeFile(output,text);report.built.push(item.name);continue;
+  }
+  try{
+   const result=await bundler.build({entryPoints:[join(item.path,'src','main.js')],bundle:true,format:'esm',platform:'neutral',target:'es2022',write:false,metafile:true,logLevel:'silent',banner:{js:BANNER},absWorkingDir:root});
+   const text=result.outputFiles[0].text;
+   report.shared[item.name]=Object.keys(result.metafile.inputs).map(input=>posix(input)).filter(input=>input.startsWith(`${SHARED_DIR}/`)).map(input=>input.slice(SHARED_DIR.length+1)).sort();
+   let current=null;try{current=await readFile(output,'utf8');}catch{}
+   if(current===text){report.unchanged.push(item.name);continue;}
+   await mkdir(dirname(output),{recursive:true});await writeFile(output,text);report.built.push(item.name);
+  }catch(error){
+   const first=error?.errors?.[0];
+   report.failed.push({block:item.name,message:first?`${first.location?`${first.location.file}:${first.location.line}: `:''}${first.text}`:String(error?.message||error)});
+  }
+ }
+ await rememberBuild(root,report);
+ return report;
+}
+async function rememberBuild(root,report){
+ const path=join(root,WORKSPACE_STATE);let state={};try{state=JSON.parse(await readFile(path,'utf8'));}catch{}
+ state.shared={...(state.shared||{}),...report.shared};
+ state.buildFailures=Object.fromEntries([...Object.entries(state.buildFailures||{}).filter(([name])=>!(report.built.includes(name)||report.unchanged.includes(name)||report.failed.some(item=>item.block===name))),...report.failed.map(item=>[item.block,item.message])]);
+ await mkdir(dirname(path),{recursive:true});await writeFile(path,json(state));
+}
+export async function readWorkspaceState(root){try{return JSON.parse(await readFile(join(root,WORKSPACE_STATE),'utf8'));}catch{return {};}}
+
+// A module Block runs one file; an import of another file fails only when it runs. Said before then.
+const RELATIVE_IMPORT=/(?:^|[;\n}])\s*(?:import|export)\s[^;'"]*?from\s*['"](\.{1,2}\/[^'"]+)['"]|\bimport\s*\(\s*['"](\.{1,2}\/[^'"]+)['"]\s*\)/;
+export async function unbundledImport(blockPath){
+ let entry='main.js';try{entry=JSON.parse(await readFile(join(blockPath,'module.json'),'utf8')).entry||entry;}catch{}
+ let text;try{text=await readFile(join(blockPath,'module',entry),'utf8');}catch{return null;}
+ const match=RELATIVE_IMPORT.exec(text);
+ return match?{file:`module/${entry}`,specifier:match[1]||match[2]}:null;
+}
+
+// --- init -----------------------------------------------------------------------------------------------------
+
+/** The readiness gate as the agents' end-of-turn hook: the project's own install of the SDK when this CLI runs from one. */
+function gateScript(){
+ const here=fileURLToPath(new URL('./ready-gate.js',import.meta.url));
+ const installed=/[\\/]node_modules[\\/]stillmade-sdk[\\/]/.test(here);
+ return {claude:installed?'"$CLAUDE_PROJECT_DIR/node_modules/stillmade-sdk/packages/block-cli/ready-gate.js"':JSON.stringify(here),cursor:installed?'node_modules/stillmade-sdk/packages/block-cli/ready-gate.js':JSON.stringify(here)};
+}
+export const WORKSPACE_GUIDE=`# This folder is a StillMade workspace
+
+It holds several StillMade Blocks, the code they share and the workflows that join them. Keep every Block here.
+
+- A new Block goes in this folder: \`npx stillmade-block add <name> [template]\` makes \`blocks/<name>/\`
+  (\`npx stillmade-block templates\` lists the templates). Never start a Block somewhere else for this person.
+- A Block that calls a signed-in app (Gmail, Slack, Notion...) starts from the \`connector\` template:
+  \`npx stillmade-block add <name> connector --app gmail\`. One that runs by itself on a schedule, a webhook or a saved
+  video starts from \`trigger-schedule\`, \`trigger-webhook\` or \`trigger-media\`.
+- A workflow (a StillMade Project Type) is \`workflows/<name>.json\`: \`npx stillmade-block add-type <name> [block ...]\`.
+  Its Steps name Blocks by folder (\`"block": "listing-facts"\`); the id and version come from that Block.
+  \`--when schedule\` starts it with StillMade's When Step, which makes it an automation.
+- Code two or more module Blocks use lives in \`shared/\`. Such a Block keeps its code in \`src/main.js\` and imports
+  from \`../../../shared/...\`; \`npx stillmade-block build\` joins it into the Block's \`module/main.js\`. Never edit a
+  built \`module/main.js\` by hand. Run \`npm install\` once so the build has esbuild.
+- The preview is \`npx stillmade-block dev\` from this folder (http://127.0.0.1:4800). It shows every Block and
+  workflow, opens the Block you last saved, and reloads by itself. If it is already running, do not start another.
+- Check everything with \`npx stillmade-block test\` and \`npx stillmade-block gate\` from this folder. A Block is not
+  ready until the gate passes for it; report the status the gate prints.
+- \`npx stillmade-block pack\` writes one \`.stillmade-pack\` file with every Block and workflow. In StillMade, Create,
+  then Import, takes it and asks which ones to bring in.
+
+Every Block here follows the StillMade Block builder contract below, exactly as a Block made alone does.
+
+`;
+export async function initWorkspace(folder,{name}={}){
+ if(await exists(join(folder,WORKSPACE_FILE)))throw usage(`${folder} is already a workspace.`);
+ if(await exists(folder)){const entries=(await readdir(folder)).filter(entry=>!entry.startsWith('.'));if(entries.length)throw usage(`${folder} is not empty. Start a workspace in a new folder.`);}
+ const title=(name||basename(folder).replace(/[-_]+/g,' ')).trim().slice(0,80)||'Blocks';
+ const config={schemaVersion:1,name:title[0].toUpperCase()+title.slice(1),version:'1.0.0'};
+ const gate=gateScript();
+ const files={
+  [WORKSPACE_FILE]:json(config),
+  [`${BLOCKS_DIR}/.gitkeep`]:'',[`${WORKFLOWS_DIR}/.gitkeep`]:'',
+  [`${SHARED_DIR}/README.md`]:`# Shared code\n\nModules here are for the workspace's module Blocks. A Block imports them from its \`src/main.js\`\n(\`import {x} from '../../../shared/x.js'\`) and \`stillmade-block build\` joins them into that Block's \`module/main.js\`,\nso every packed Block still stands alone.\n`,
+  'package.json':json({name:folderName(basename(folder)||'blocks'),private:true,type:'module',scripts:{dev:'stillmade-block dev',build:'stillmade-block build',test:'stillmade-block test',gate:'stillmade-block gate',pack:'stillmade-block pack'},devDependencies:{esbuild:'0.25.10','stillmade-sdk':`^${SDK_VERSION}`}}),
+  '.gitignore':'node_modules/\n.stillmade/\n*.stillmade-pack\n',
+  'AGENTS.md':WORKSPACE_GUIDE+renderBuilderContract('agents-md'),
+  'CLAUDE.md':'Read AGENTS.md first: this folder is a StillMade workspace, and AGENTS.md says where new Blocks go and how they are checked.\n',
+  '.cursor/rules/stillmade-workspace.mdc':`---\ndescription: StillMade workspace\nalwaysApply: true\n---\n${WORKSPACE_GUIDE}Read AGENTS.md for the full Block builder contract.\n`,
+  '.claude/settings.json':json({hooks:{Stop:[{hooks:[{type:'command',command:`node ${gate.claude} --claude`,timeout:600}]}]}}),
+  '.cursor/hooks.json':json({version:1,hooks:{stop:[{command:`node ${gate.cursor} --cursor`,timeout:600}]}}),
+ };
+ await mkdir(folder,{recursive:true});
+ for(const [path,text] of Object.entries(files)){await mkdir(dirname(join(folder,path)),{recursive:true});await writeFile(join(folder,path),text,{flag:'wx'});}
+ return {created:folder,kind:'workspace',name:config.name,files:Object.keys(files),next:'Run `npm install` once in this folder, then `npx stillmade-block add <name> [template]` for each Block and `npx stillmade-block dev` to preview them all.'};
+}
+
+/** After `create` made blocks/<name>: a module Block keeps its code in src/main.js, built into module/. */
+export async function adoptWorkspaceBlock(path){
+ const manifest=JSON.parse(await readFile(join(path,'stillmade.block.json'),'utf8'));
+ if(manifest.runtime!=='module')return {source:null};
+ let entry='main.js';try{entry=JSON.parse(await readFile(join(path,'module.json'),'utf8')).entry||entry;}catch{}
+ let text;try{text=await readFile(join(path,'module',entry),'utf8');}catch{return {source:null};}
+ await mkdir(join(path,'src'),{recursive:true});
+ await writeFile(join(path,'src','main.js'),text,{flag:'wx'});
+ return {source:'src/main.js'};
+}

package/packages/block-platform/block-readiness.js

@@ -15,7 +15,7 @@ import {initialBlockState,validateBlockState} from '../block-sdk/state.js';
 import {createUniversalResolver} from '../block-sdk/universal-resolver.js';
 import {requiresDesktopExecution} from '../block-sdk/desktop-execution.js';
 import {mobileActivationStatus} from '../block-sdk/platform-checks.js';
-import {blockKitProblems,BLOCK_KIT_READINESS_RULES,unmarkedButtons,viewWordingNotes} from '../block-sdk/view-design.js';
+import {blockKitProblems,BLOCK_KIT_READINESS_RULES,unmarkedButtons,viewWordingNotes,interfaceMode} from '../block-sdk/view-design.js';
 import {FIRST_PARTY_SDK_PACKAGES} from '../block-sdk/first-party-packages.js';
 import {previewProjectType} from './type-preview.js';
 import {semanticRegistryForManifests} from '../block-sdk/package-semantics.js';
@@ -59,7 +59,7 @@ export function jobWordingNotes(pkg){
  // box on the Step page, so only an input with no control at all is noted.
  const lined=Object.entries(manifest.inputs||{}).filter(([name,port])=>{const control=(manifest.ui||[]).find(item=>item?.port===name);return port?.type==='text'&&!control&&(pkg?.tests||[]).some(test=>typeof test?.input?.[name]==='string'&&test.input[name].includes('\n'));}).map(([name])=>name);
  if(lined.length)notes.push(`${lined.length===1?`The input ${lined[0]} has examples`:`The inputs ${lined.join(', ')} have examples`} of several lines but ${lined.length===1?'is':'are'} not declared multi-line, so a host can draw one line and lose the line breaks. Add {"control":"text","port":"${lined[0]}","multiline":true} to manifest.ui${lined.length===1?'':' for each'}.`);
-  if(pkg?.view)notes.push(...viewWordingNotes(pkg.view));
+  if(pkg?.view)notes.push(...viewWordingNotes(pkg.view,{mode:interfaceMode(manifest)}));
  if(bare.length)notes.push(`${bare.length===1?`The input ${bare[0]} is`:`The inputs ${bare.join(', ')} are`} named only by type, so the drop area reads "Drop a ${bare[0].replace(/s$/,'')} here". Name each for what the person brings (sermonVideo), unless any file of that kind does the job.`);
  return notes;
 }
@@ -177,12 +177,13 @@ export async function assessBlockReadiness(pkg,{catalog=FIRST_PARTY_SDK_PACKAGES
  else notVerified('DOD-13',sharedEditing?.reason||'The shared-interface source contract passed; two-participant runtime behavior has not been checked.');
  // A new interface names its action, shows no price and no page heading before device checks
  // count. StillMade's own built-in Blocks (sm.*) are redesigned separately.
- const kit=String(manifest.id).startsWith('sm.')?[]:blockKitProblems(pkg.view).filter(problem=>BLOCK_KIT_READINESS_RULES.includes(problem.rule));
+ const kit=String(manifest.id).startsWith('sm.')?[]:blockKitProblems(pkg.view,{mode:interfaceMode(manifest)}).filter(problem=>BLOCK_KIT_READINESS_RULES.includes(problem.rule));
  if(kit.length)failed('DOD-15',kit.map(problem=>problem.message).join(' '));
  const ui=platformChecks?mobileActivationStatus(platformChecks,sourceDigest,manifest):null;
  if(ui?.ready)verified('DOD-15',ui.reason);else notVerified('DOD-15',ui?.reason||'Device UI checks have not run for this exact package.');
  // October 30, 2026: a button Chat cannot press is a documented limitation, never a refusal.
- const unmarked=String(manifest.id).startsWith('sm.')?0:unmarkedButtons(pkg.view);
+ // November 6, 2026: an app's tool buttons are its own (an editor has dozens); only its run button needs the mark.
+ const unmarked=String(manifest.id).startsWith('sm.')||interfaceMode(manifest)==='app'?0:unmarkedButtons(pkg.view);
  if(unmarked){const warning=`${unmarked===1?'A button':`${unmarked} buttons`} in the view ${unmarked===1?'has':'have'} no data-stillmade-action, so Chat cannot press ${unmarked===1?'it':'them'}. Give each button data-stillmade-action naming what it does.`,current=items.get('DOD-15');notVerified('DOD-15',current?.state==='not-verified'?`${current.reason} ${warning}`:warning);}
 
  if(hosted){

package/packages/block-platform/catalog.js

@@ -1,4 +1,5 @@
 import {FIRST_PARTY_SDK_PACKAGES} from '../block-sdk/first-party-packages.js';
+import {STAGED_FIRST_PARTY_RELEASES} from '../block-sdk/staged-releases.js';
 import { SDK_VERSION, ROOT_CHAT_ID } from '../block-sdk/contracts.js';
 import {VIDEO_ASSETS_BLOCK} from './video-assets.js';
 import {HOST_RELEASE_MANIFEST_SNAPSHOTS} from './host-release-manifests.js';
@@ -129,8 +130,9 @@ export const AUTOMATION_PARTS=new Set([]);
 // November 4, 2026 (owner): Generate (stillmade.generate) is the one Block for every image and video model; Generate
 // image and Generate video stay only as the Canvas's own generation nodes.
 export const HIDDEN_BLOCKS=new Set(['sm.generate-image','sm.generate-video','sm.final-edit','sm.edit-assistant','sm.character','sm.location','sm.style','sm.compare','sm.score','sm.rough-cut',...BLOCK_TOOLS,...AUTOMATION_PARTS]);
-// Exact releases to hide (id@version) when one release of a shown Block should not be offered; none today.
-export const HIDDEN_RELEASES=new Set([]);
+// Exact releases to hide (id@version) when one release of a shown Block should not be offered: the staged first-party
+// releases (staged-releases.js), which resolve for exact pins only.
+export const HIDDEN_RELEASES=new Set([...STAGED_FIRST_PARTY_RELEASES]);
 export const isHiddenBlock=block=>HIDDEN_BLOCKS.has(block.manifest.id)||HIDDEN_RELEASES.has(`${block.manifest.id}@${block.manifest.version}`);
 // Export video is offered as the original Editor opened at its Export (1.0.0), so
 // people can still change the cut before rendering (the owner, Oct 15). The
@@ -154,7 +156,7 @@ export const isOfferedBlock=block=>block.manifest.id!==STARTING_CHAT_BLOCK.manif
 // none of, so planning keeps the newest render-only release in its place. Chat
 // builds then fold it into the Editor (compact-project.js), so people still get
 // the Editor at its Export.
-const newestRelease=id=>SDK_BUILTIN_BLOCKS.filter(block=>block.manifest.id===id).reduce((best,block)=>!best||newer(block.manifest.version,best.manifest.version)?block:best,null);
+const newestRelease=id=>SDK_BUILTIN_BLOCKS.filter(block=>block.manifest.id===id&&!HIDDEN_RELEASES.has(`${id}@${block.manifest.version}`)).reduce((best,block)=>!best||newer(block.manifest.version,best.manifest.version)?block:best,null);
 // What people browse (Add Block, the Marketplace): one card per Block. The Editor is the full video
 // editor (its host release); its portable releases stay discoverable for planning only (October 22, 2026:
 // Add Block listed Video editor, Editor 2.2.11 and Editor 2.2.12).

package/packages/block-platform/node-defaults.js

@@ -34,7 +34,7 @@ export function defaultNodeData(type, request = {}, sceneNumber = 1, {llmModel,
       projectTitle: request.projectTitle || '',
       thumbnailBrief: prompt,
       text: prompt,
-      model: 'gpt-image-2',
+      model: 'gpt-image-2.5-sunburst',
       aspectRatio: '16:9',
       resolution: '1K',
       variations: 1,
@@ -56,7 +56,7 @@ export function defaultNodeData(type, request = {}, sceneNumber = 1, {llmModel,
       readablePrompt: request.prompt || `Scene ${sceneNumber} image prompt.`,
       characterRefs: [],
       locationRefs: [],
-      model: 'gpt-image-2',
+      model: 'gpt-image-2.5-sunburst',
       aspectRatio: '16:9',
       quality: 'medium',
       resolution: '1K',

package/packages/block-platform/plain-descriptions.js

@@ -21,6 +21,7 @@ export const PLAIN_BLOCK_DESCRIPTIONS=Object.freeze({
  'sm.grade':'Change the colors of chosen clips with ready-made looks or simple sliders. Your originals stay as they are.',
  'sm.transition':'Pick transitions between clips, with their timing and sounds, then apply them in the Editor.',
  'sm.compare':'Compare two images with a slider and keep the one you prefer.',
+ 'sm.photo-editor':'Edit a photo: light, color, crop and straighten, presets, before and after. Saved at full size.',
  'sm.photo-notes':'Rate up to four photos for sharpness, light, people and faces.',
  'sm.export-timeline':'Download your timeline to open in another editor, with or without its media.',
  'sm.captions':'Turn a transcript or text into captions with word highlighting, then add them to the timeline.',

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

@@ -80,6 +80,14 @@ 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 project made of one Block, as Marketplace's "Use block" starts it (owner, November 6, 2026: it opened the
+// Block on its own instead of a project with it). Built-in Blocks come from the catalog when the project is
+// compiled; any other Block travels inside the workflow as its exact package.
+export function singleBlockType(pkg) {
+  const manifest = pkg.manifest || pkg, builtin = BUILTIN_BLOCKS.some(item => item.manifest.id === manifest.id && item.manifest.version === manifest.version) || SUPPORTED_HOST_BLOCKS.includes(manifest.id);
+  return { schemaVersion: 1, id: `workspace.${manifest.id.replace(/^sm\./, '')}`, version: '1.0.0', name: manifest.name, description: manifest.description,
+    stages: [{ id: 'workspace', blockId: manifest.id, version: manifest.version, label: manifest.name }], ...(builtin ? {} : { packages: [structuredClone(pkg)] }) };
+}
 // 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 = {

package/packages/block-sdk/admission.js

@@ -8,7 +8,7 @@ import {testPlatforms} from './platform-checks.js';
 import {requiresDesktopExecution} from './desktop-execution.js';
 import {runPackageAsync} from './runtime.js';
 import {validateViewAppearance} from './appearance.js';
-import {reviewViewDesign} from './view-design.js';
+import {reviewViewDesign,interfaceMode} from './view-design.js';
 import {reviewCollaborationContract} from './collaboration-admission.js';
 import {reviewModelPortability} from './model-portability.js';
 import {sharedAgentControls} from './shared-agent-controls.js';
@@ -99,7 +99,7 @@ export function scanPackageSource(pkg) {
  else results.push({name:'Static code review',passed:true,message:pkg.manifest.runtime === 'comfyui' ? 'Only reviewed core image nodes and bounded typed bindings; no custom Python, dependencies, credentials, or paths' : pkg.manifest.runtime === 'capability' ? `Bounded declarative ${pkg.capability.operation} request only; provider, model, payment and approval belong to the host. No live execution has been verified.` : 'Only allowlisted recipe operations and bounded JSON are accepted'});
  if(pkg.view){
   results.push({name:'Sandbox interface review',passed:true,message:pkg.view.runtime==='frame'?'Frame view: any interface code, compiled with task guards and run in an opaque-origin frame with no network, generated code, navigation, popups or WebAssembly':'Bounded HTML controls and reviewed standalone UI JavaScript; opaque-origin frame, no navigation or remote resources'});
-  const design=reviewViewDesign(pkg.view),notes=[...design.issues,...design.warnings];
+  const design=reviewViewDesign(pkg.view,{mode:interfaceMode(pkg.manifest)}),notes=[...design.issues,...design.warnings];
   results.push({name:'Task interface design',passed:design.passed,message:notes.length?notes.join(' '):'The task object leads, choices are bounded, and secondary detail stays progressively disclosed.'});
  }
  try {validateViewAppearance(pkg.view);results.push({name:'Appearance compatibility',passed:true,message:pkg.view?.appearance==='original'?'Interface preserves its declared original colors; StillMade theming is optional. Sandbox and shared-state checks still apply.':'Interface follows Light, Dark and White; original preview colors are preserved'});} catch(error) {results.push(pkg.view?.runtime==='frame'?{name:'Appearance compatibility',passed:true,advisory:true,message:`Advice: ${error.message} Frame views receive the theme variables; using them keeps the interface right in Light, Dark and White.`}:{name:'Appearance compatibility',passed:false,message:error.message});}

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

@@ -9,7 +9,7 @@
 import {HOSTED_OPERATION_NAMES} from './contracts.js';
 
 export const BUILDER_CONTRACT_ID='stillmade.block-builder';
-export const BUILDER_CONTRACT_VERSION='1.17.0';
+export const BUILDER_CONTRACT_VERSION='1.18.0';
 export const BUILDER_CONTRACT_STAMP=`${BUILDER_CONTRACT_ID}@${BUILDER_CONTRACT_VERSION}`;
 export const BUILDER_CONTRACT_DOCS_PATH='/docs/build/block-builder-contract';
 // Block names appear in step bars, cards and pickers; new releases keep them short.
@@ -86,8 +86,8 @@ 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. 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 after the inputs. Actions and status sit on the stage (`sm-actions`, `sm-status` in `sm-stage`); the run button stays rightmost, so making again never moves.',
-  '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 after the inputs with the job\'s action row on it (`sm-actions` and `sm-status` inside `sm-stage`: the kit puts the status top-left and the actions top-right in the player\'s cream blocks, over a band above the media; the run button is always the rightmost, so a button that spends credits never moves and making again is pressed where it made the first time, with Download and other result actions to its left), 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; a stage shows what it holds in its middle as one group (a caption stays with its picture) and several results fill its width as one row, on a Block\'s screen and on the pages StillMade draws; 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 for 3 s the first time it comes into view, then 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.'),
+  '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) sets `manifest.kind: "workspace"` and works like that app: full canvas, panels, tools, undo, never a form; checks then use the app rules. 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 after the inputs. Actions and status sit on the stage (`sm-actions`, `sm-status` in `sm-stage`); the run button stays rightmost, so making again never moves.',
+  '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 after the inputs with the job\'s action row on it (`sm-actions` and `sm-status` inside `sm-stage`: the kit puts the status top-left and the actions top-right in the player\'s cream blocks, over a band above the media; the run button is always the rightmost, so a button that spends credits never moves and making again is pressed where it made the first time, with Download and other result actions to its left), 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, photo editor), declares `manifest.kind: "workspace"` and looks and works like that kind of app instead of a compact page, and StillMade\'s checks (admission, readiness, its own builder) then apply the app rules instead of the compact ones: no limit on controls in view, no Block kit page, its own layout, the craft\'s own words, and only its run button (`data-stillmade-action="run"`) held to naming what it makes: 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; a stage shows what it holds in its middle as one group (a caption stays with its picture) and several results fill its width as one row, on a Block\'s screen and on the pages StillMade draws; 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 for 3 s the first time it comes into view, then 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',
   'StillMade shares every screen control (`data-stillmade-local` keeps one local); a view sharing its own state (`updateShared`) adds `onShared`, `canEdit`, no re-run on remote edits.',
   'Projects are multiplayer, and StillMade builds it: every ordinary control on a Block\'s screen (text, number, range, checkbox, color, select, textarea and a kit choice group) is shared by itself, under its `data-stillmade-share`, else its `name`, else its `id`, including controls the screen adds later; the Block writes no sharing code. `StillMade.bindShared(field, elementId)` shares a control under another field name. Mark a truly device-only control (playback, hover, device selection), or an element around several, with `data-stillmade-local`. A view that publishes its own structured state (`StillMade.updateShared(values, before, options)` or `StillMade.connectDocument`) shares its controls itself: StillMade then steps aside, and it subscribes through `StillMade.onShared(callback)`; private variables and canvas drawings are not shared unless the view publishes them. 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.'),