stillmade-sdk 0.1.35 → 0.1.36

package/packages/block-sdk/module-worker.js

@@ -14,12 +14,40 @@ export const MODULE_WORKER_SOURCE = String.raw`(function(scope){
  function text(value){try{return typeof value==='string'?value:JSON.stringify(value);}catch(e){return String(value);}}
  async function bufferOf(data){
   // A copy, so the Block's own buffer stays usable after the host takes the bytes.
+  // Shared memory (threaded WebAssembly) is copied into an ordinary buffer, which can be transferred.
   if(data instanceof ArrayBuffer)return data.slice(0);
-  if(ArrayBuffer.isView(data))return data.buffer.slice(data.byteOffset,data.byteOffset+data.byteLength);
+  if(typeof SharedArrayBuffer!=='undefined'&&data instanceof SharedArrayBuffer){var whole=new ArrayBuffer(data.byteLength);new Uint8Array(whole).set(new Uint8Array(data));return whole;}
+  if(ArrayBuffer.isView(data)){var copy=new ArrayBuffer(data.byteLength);new Uint8Array(copy).set(new Uint8Array(data.buffer,data.byteOffset,data.byteLength));return copy;}
   if(data&&typeof data.arrayBuffer==='function')return data.arrayBuffer();
   if(typeof data==='string')return new TextEncoder().encode(data).buffer;
   throw new TypeError('files.write takes an ArrayBuffer, typed array, Blob or string');
  }
+ // Live connections the host opened for this run, by id: each receives its
+ // messages and close from the host and keeps them for its listeners and iterator.
+ var sockets=new Map();
+ function liveSocket(id,url,protocol){
+  var target=new EventTarget(),state=1,queue=[],queued=0,waiting=[],ended=null,finish;
+  var closed=new Promise(function(resolve){finish=resolve;});
+  function dispatch(type,fields){var event=new Event(type);Object.keys(fields).forEach(function(key){Object.defineProperty(event,key,{value:fields[key],enumerable:true});});var handler=socket['on'+type];if(typeof handler==='function'){try{handler.call(socket,event);}catch(error){setTimeout(function(){throw error;});}}target.dispatchEvent(event);}
+  // for await (const data of socket) yields every message not yet read, including ones that
+  // arrived before the loop began: at most 1,024 messages or 16 MiB wait, the oldest dropped first.
+  function size(data){return typeof data==='string'?data.length*2:data.byteLength||0;}
+  function settle(){while(waiting.length&&(queue.length||ended)){var next=waiting.shift();if(queue.length){var data=queue.shift();queued-=size(data);next({value:data,done:false});}else next({value:undefined,done:true});}}
+  var socket={
+   url:url,protocol:protocol,binaryType:'arraybuffer',onmessage:null,onclose:null,closed:closed,
+   get readyState(){return state;},
+   send:async function(data){if(state!==1)throw Object.assign(new Error('This live connection is not open.'),{code:'NETWORK_SOCKET_CLOSED'});var payload=typeof data==='string'?data:await bufferOf(data);return call('net.socket',{id:id,op:'send',data:payload},typeof payload==='string'?[]:[payload]);},
+   close:function(code,reason){if(state>=2)return closed;state=2;call('net.socket',{id:id,op:'close',code:code,reason:reason}).catch(function(){});return closed;},
+   addEventListener:function(type,listener,options){target.addEventListener(type,listener,options);},
+   removeEventListener:function(type,listener,options){target.removeEventListener(type,listener,options);}
+  };
+  socket[Symbol.asyncIterator]=function(){return {next:function(){return new Promise(function(resolve){waiting.push(resolve);settle();});},return:function(){socket.close();return Promise.resolve({value:undefined,done:true});}};};
+  sockets.set(id,function(message){
+   if(message.event==='message'){queue.push(message.data);queued+=size(message.data);while(queue.length>1024||queued>16777216){queued-=size(queue.shift());}dispatch('message',{data:message.data});settle();}
+   else if(message.event==='close'){state=3;sockets.delete(id);ended={code:message.code,reason:message.reason,wasClean:message.wasClean};dispatch('close',ended);finish(ended);settle();}
+  });
+  return socket;
+ }
  function call(api,args,transfer){return new Promise(function(resolve,reject){var id=++sequence;pending.set(id,{resolve:resolve,reject:reject});post({type:'call',id:id,api:api,args:args},transfer);});}
  var host=Object.freeze({
   signal:controller.signal,
@@ -67,6 +95,14 @@ export const MODULE_WORKER_SOURCE = String.raw`(function(scope){
    var result=await call('net.fetch',{request:{url:String(url&&url.href||url),method:method,headers:headers,body:body}},body?[body]:[]);
    var empty=method==='HEAD'||[101,204,205,304].indexOf(result.status)>=0;
    return new Response(empty?null:result.body,{status:result.status,statusText:result.statusText||'',headers:result.headers||{}});
+  },
+  // A live WebSocket to the wss:// form of a declared origin, opened by the
+  // host outside this sandbox. Resolves once it is open; no key is added.
+  connect:async function(url,options){
+   options=options||{};var href=String(url&&url.href||url),given=options.protocols;
+   var protocols=given==null?[]:Array.isArray(given)?given.map(String):[String(given)];
+   var opened=await call('net.connect',{request:{url:href,protocols:protocols}});
+   return liveSocket(opened.id,href,opened.protocol);
   }})
  });
  async function load(source){
@@ -83,6 +119,7 @@ export const MODULE_WORKER_SOURCE = String.raw`(function(scope){
    return;
   }
   if(message.type==='cancel'){controller.abort();return;}
+  if(message.type==='socket'){var deliver=sockets.get(message.id);if(deliver)deliver(message);return;}
   if(message.type!=='start'||started)return;
   started=true;files=message.files||{};
   try{

package/packages/block-sdk/network.js

@@ -87,6 +87,26 @@ export function networkRequest(request,declarations){
  return {url:url.href,origin:url.origin,method,headers:normalized,body:bytes,auth:declared.auth};
 }
 
+// Live connections (stillmade.net.connect): a WebSocket to the wss:// form of a
+// declared origin, opened by StillMade outside the Block's sandbox and relayed
+// message by message. The host adds no key to it: a service that needs one is
+// asked for a short-lived token with net.fetch first.
+export const SOCKET_LIMITS=Object.freeze({sockets:4,messageBytes:1048576,runBytes:268435456,protocols:8});
+const SUBPROTOCOL=/^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,64}$/;
+/** Check one live connection a Block opens. Returns {url, origin, protocols}. */
+export function socketRequest(request,declarations){
+ if(!plain(request))fail('net.connect takes a wss:// URL and options');
+ const {url:raw,protocols=[]}=request;
+ if(typeof raw!=='string'||raw.length>NETWORK_LIMITS.urlLength)fail('net.connect needs a full wss:// URL');
+ let url;try{url=new URL(raw);}catch{fail('net.connect needs a full wss:// URL');}
+ if(url.protocol!=='wss:'||url.username||url.password||url.port)fail('net.connect opens wss:// URLs on the standard port, without credentials');
+ url.hash='';
+ const origin=`https://${url.host}`;
+ if(!declarations.some(entry=>entry.origin===origin))fail(`${origin} is not one of this Block's declared network origins`,'NETWORK_ORIGIN');
+ if(!Array.isArray(protocols)||protocols.length>SOCKET_LIMITS.protocols||new Set(protocols).size!==protocols.length||!protocols.every(name=>typeof name==='string'&&SUBPROTOCOL.test(name)))fail(`net.connect protocols are up to ${SOCKET_LIMITS.protocols} distinct subprotocol names`);
+ return {url:url.href,origin,protocols:[...protocols]};
+}
+
 // The apps a module Block declares in permissions.connections, by public app ID:
 // - published OpenAPI adapters (app:openapi:<slug>): the server builds each
 //   request from the reviewed definition and adds the person's own key or

package/packages/block-sdk/permission-summary.js

@@ -0,0 +1,97 @@
+// What a Block can do, in words a person reads at import, install and update,
+// instead of its raw permission JSON. Every Block is held to what it declares:
+// the host refuses anything else, so this summary is the whole of what a Block
+// can reach. `level` says how much care a Block needs, from what it can reach:
+//   none   it works only inside StillMade (media in, media out, project edits you accept)
+//   low    it reaches what you choose at the moment (a folder you pick, the camera after Start),
+//          or talks to the sites it names
+//   medium it changes your files, reads your clipboard or cursor, or uses an account you connected
+//   high   it runs a program on your computer, or can send what it reads from your device to a site
+import {networkDeclarations,connectionDeclarations} from './network.js';
+
+export const PERMISSION_LEVELS=Object.freeze(['none','low','medium','high']);
+const rank=level=>PERMISSION_LEVELS.indexOf(level);
+const higher=(a,b)=>rank(a)>=rank(b)?a:b;
+
+const DESKTOP={
+ 'screen.capture':['Records your screen or a window you choose, after you press Start','low','device'],
+ 'camera.capture':['Uses your camera after you press Start','low','device'],
+ 'microphone.capture':['Uses your microphone after you press Start','low','device'],
+ 'cursor.track':['Sees where your cursor is on screen','medium','device'],
+ 'clipboard.read':['Reads text you copied','medium','device'],
+ 'clipboard.write':['Replaces the text you copied','low',null],
+ 'media.pick':['Opens media files you choose','none','chosen'],
+ 'notifications.show':['Shows notifications','none',null],
+ 'power.keep-awake':['Keeps your computer awake while it works','none',null],
+ 'native.tools':['Runs an approved program on your computer through StillMade','high',null],
+ 'folder.read':['Reads files in a folder you choose','low','device'],
+ 'folder.write':['Creates and replaces media and text files in a folder you choose','medium',null],
+};
+const HOSTED={
+ 'text.generate':'writes text with AI','audio.speech':'turns text into speech','audio.transcribe':'transcribes audio',
+ 'audio.music':'generates music','audio.sfx':'generates sound effects','image.generate':'generates images',
+ 'video.generate':'generates video','image.describe':'describes images','media.analyze':'analyzes media',
+ 'web.fetch':'reads a public web page','web.research':'researches a topic on the web','timeline.propose':'suggests timeline edits',
+ 'workspace.propose':'suggests workspace edits','connection.execute':'uses an app you connected','comfyui.execute':'runs a ComfyUI workflow',
+};
+const ACTIONS={
+ 'final.render':'renders your final video','stock.search':'searches stock media','presenter.generate':'makes a presenter video',
+ 'quality.analyze':'checks quality','image.generate':'generates images','image.generate.batch':'generates images in batches',
+ 'media.generate':'generates media','youtube.upload':'uploads to your YouTube channel after you confirm',
+};
+const app=entry=>entry.slug.replace(/[-_]+/g,' ');
+// Hosted operations and actions that send what a Block gives them to a place the
+// Block chooses: a web address, a connected app, a public upload.
+const OUTWARD_SERVICES=Object.freeze({'web.fetch':'web pages it chooses','web.research':'web searches','connection.execute':'a connected app'});
+const OUTWARD_ACTIONS=Object.freeze({'youtube.upload':'your YouTube channel'});
+
+const host=origin=>{try{return new URL(origin).host;}catch{return String(origin);}};
+const list=items=>items.length<=2?items.join(' and '):`${items.slice(0,-1).join(', ')} and ${items.at(-1)}`;
+
+/** Plain-language lines and an overall level for a manifest's permissions. */
+export function summarizePermissions(manifest){
+ const permissions=manifest?.permissions||{},lines=[];let level='none';
+ const add=(id,text,lineLevel,family)=>{lines.push({id,text,level:lineLevel,family});level=higher(level,lineLevel);};
+ const project=Array.isArray(permissions.project)?permissions.project:[];
+ const reads=project.filter(scope=>/^context\.[a-zA-Z]+\.read$/.test(scope)||['project.read','timeline.read','asset.read'].includes(scope));
+ if(reads.length)add('project.read','Reads the parts of this project it works on','none','project');
+ if(project.some(scope=>/\.propose$/.test(scope)||scope==='project.patch'))add('project.propose','Suggests changes to your project that you accept or decline','none','project');
+ if(project.includes('asset.create')||project.includes('asset.version.append'))add('asset.create','Adds media to your project','none','project');
+ if(project.includes('work.shared'))add('work.shared','Shares work with people on this project','low','project');
+ const hosted=(Array.isArray(permissions.capabilities)?permissions.capabilities:[]).map(name=>HOSTED[name]||name);
+ if(hosted.length)add('capabilities',`Uses StillMade services that ${list(hosted)}, with credits you approve`,'low','service');
+ const actions=(Array.isArray(permissions.actions)?permissions.actions:[]).map(name=>ACTIONS[name]||name);
+ if(actions.length)add('actions',`Asks StillMade to do work that ${list(actions)}`,'low','service');
+ let network=[],connections=[];
+ try{network=networkDeclarations(permissions.network);}catch{}
+ try{connections=connectionDeclarations(permissions.connections);}catch{}
+ if(network.length){
+  const plainOrigins=network.filter(entry=>!entry.auth).map(entry=>host(entry.origin)),keyed=network.filter(entry=>entry.auth).map(entry=>host(entry.origin));
+  if(plainOrigins.length)add('network',`Connects to ${list(plainOrigins)}`,'low','network');
+  if(keyed.length)add('network.auth',`Uses a key you enter to connect to ${list(keyed)}`,'medium','network');
+ }
+ if(connections.length)add('connections',`Uses ${connections.length===1?'an account':'accounts'} you connected (${list(connections.map(app))})`,'medium','network');
+ const desktop=Array.isArray(permissions.desktop)?permissions.desktop:[];
+ for(const scope of desktop)if(DESKTOP[scope])add(scope,DESKTOP[scope][0],DESKTOP[scope][1],'device');
+ // The one combination that matters most: something read from the device, and a way out.
+ const services=Array.isArray(permissions.capabilities)?permissions.capabilities:[],asked=Array.isArray(permissions.actions)?permissions.actions:[];
+ const fromDevice=desktop.filter(scope=>DESKTOP[scope]?.[2]==='device'),outward=[...network.map(entry=>host(entry.origin)),...connections.map(app),...services.filter(name=>OUTWARD_SERVICES[name]).map(name=>OUTWARD_SERVICES[name]),...asked.filter(name=>OUTWARD_ACTIONS[name]).map(name=>OUTWARD_ACTIONS[name])];
+ const dataLeaves=fromDevice.length>0&&outward.length>0;
+ if(dataLeaves)add('data.leaves',`Can send what it reads from your computer to ${list([...new Set(outward)])}`,'high','network');
+ const inside=!network.length&&!connections.length;
+ return {level,lines,dataLeaves,staysInStillMade:inside&&!desktop.length,headline:headline(level,inside)};
+}
+
+function headline(level,inside){
+ if(level==='none')return 'Works only inside StillMade';
+ if(level==='low')return inside?'Uses only what you choose':'Uses what you choose and the sites it names';
+ if(level==='medium')return 'Can change files or use your accounts';
+ return 'Needs your trust: it can run programs or send data from your computer';
+}
+
+/** What an update adds: lines in next that previous lacked (by id), and whether its level rose. */
+export function permissionChanges(previousManifest,nextManifest){
+ const before=summarizePermissions(previousManifest),after=summarizePermissions(nextManifest),known=new Set(before.lines.map(line=>line.id+'\u0000'+line.text));
+ const added=after.lines.filter(line=>!known.has(line.id+'\u0000'+line.text));
+ return {added,removed:before.lines.filter(line=>!after.lines.some(next=>next.id===line.id&&next.text===line.text)),levelRaised:rank(after.level)>rank(before.level),before,after};
+}

package/packages/block-sdk/permission-usage.js

@@ -0,0 +1,72 @@
+// Which permissions a Block's own source uses, so a creator never has to work them
+// out: the CLI reports what the source calls but does not declare (StillMade would
+// refuse it at run time) and what it declares but never calls (people would be
+// told it can do more than it does), and `permissions --fix` corrects the
+// manifest. Advice only: it reads string literals in the view, the JavaScript and
+// the module files, so a call built at run time can hide from it, and it never
+// blocks a test, pack or release.
+import {DESKTOP_PERMISSIONS} from './desktop-permissions.js';
+import {networkDeclarations,networkOrigin} from './network.js';
+
+const OPERATION_SCOPES={
+ 'clipboard.read':'clipboard.read','clipboard.write':'clipboard.write','cursor.track':'cursor.track',
+ 'media.pick':'media.pick','notifications.show':'notifications.show','power.keep-awake':'power.keep-awake',
+};
+const RECORDING=['screen.capture','camera.capture','microphone.capture'];
+const TEXT_FILE=/\.(m?js|cjs|jsx|ts|tsx|html?|json)$/i;
+const decoder=new TextDecoder('utf-8',{fatal:false});
+
+/** The text a package's code is written in: interface, JavaScript and module text files. */
+export function packageSourceText(pkg,files={},{view=true}={}){
+ const parts=[...(view?[pkg?.view?.html,pkg?.view?.javascript]:[]),pkg?.code];
+ for(const [name,value] of Object.entries(files||{})){
+  if(!TEXT_FILE.test(name.replace(/^view:/,''))||!view&&name.startsWith('view:'))continue;
+  parts.push(typeof value==='string'?value:decoder.decode(value instanceof Uint8Array?value:new Uint8Array(value)));
+ }
+ return parts.filter(part=>typeof part==='string').join('\n');
+}
+
+const literal=(text,value)=>new RegExp(`['"\`]${value.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')}['"\`]`).test(text);
+
+/** Desktop scopes and network origins the source uses, and how they compare with the manifest. */
+export function permissionUsage(pkg,files={}){
+ const text=packageSourceText(pkg,files),manifest=pkg?.manifest||{},declaredDesktop=manifest.permissions?.desktop||[];
+ const desktop=new Set();
+ for(const [operation,scope] of Object.entries(OPERATION_SCOPES))if(literal(text,operation))desktop.add(scope);
+ const folderCalls=['folder.pick','folder.shared','folder.list','folder.read','folder.write','folder.forget'].filter(operation=>literal(text,operation));
+ if(folderCalls.length)desktop.add('folder.read');
+ if(literal(text,'folder.write')||folderCalls.includes('folder.pick')&&/write\s*:\s*true/.test(text))desktop.add('folder.write');
+ if(/['"`]tool\.[a-z.]+['"`]/.test(text))desktop.add('native.tools');
+ // Which device a recording or live feed uses is decided at run time; any call keeps the declared recording scopes.
+ const records=literal(text,'record.start')||literal(text,'live.start');
+ let declaredOrigins=[];try{declaredOrigins=networkDeclarations(manifest.permissions?.network).map(entry=>entry.origin);}catch{}
+ // Network calls run in module code, never in the interface, whose links are only text.
+ const code=packageSourceText(pkg,files,{view:false}),calls=/\bnet\s*\.\s*(fetch|connect)\b/.test(code),origins=new Set();
+ for(const match of code.matchAll(/['"`]((?:https|wss):\/\/[a-z0-9.-]+(?::\d+)?)[/'"`?#]/gi)){
+  try{origins.add(networkOrigin(match[1].replace(/^wss:/i,'https:')));}catch{}
+ }
+ const undeclared=[],unused=[];
+ for(const scope of desktop)if(!declaredDesktop.includes(scope))undeclared.push({family:'desktop',scope});
+ for(const scope of declaredDesktop){
+  if(RECORDING.includes(scope)){if(!records)unused.push({family:'desktop',scope});continue;}
+  if(!desktop.has(scope)&&DESKTOP_PERMISSIONS.includes(scope))unused.push({family:'desktop',scope});
+ }
+ if(calls)for(const origin of origins)if(!declaredOrigins.includes(origin))undeclared.push({family:'network',scope:origin});
+ if(!calls)for(const origin of declaredOrigins)unused.push({family:'network',scope:origin});
+ return {desktop:[...desktop],origins:[...origins],undeclared,unused};
+}
+
+/** The manifest with what the source uses declared and what it never uses removed. */
+export function fixPermissions(manifest,usage){
+ const permissions={...manifest.permissions};
+ let desktop=[...(permissions.desktop||[])];
+ desktop=desktop.filter(scope=>!usage.unused.some(item=>item.family==='desktop'&&item.scope===scope));
+ for(const item of usage.undeclared)if(item.family==='desktop'&&!desktop.includes(item.scope))desktop.push(item.scope);
+ if(desktop.includes('folder.write')&&!desktop.includes('folder.read'))desktop.push('folder.read');
+ if(desktop.length||permissions.desktop)permissions.desktop=DESKTOP_PERMISSIONS.filter(scope=>desktop.includes(scope));
+ let network=[...(permissions.network||[])];
+ network=network.filter(entry=>!usage.unused.some(item=>item.family==='network'&&item.scope===(typeof entry==='string'?entry:entry.origin)));
+ for(const item of usage.undeclared)if(item.family==='network')network.push(item.scope);
+ if(network.length||permissions.network)permissions.network=network;
+ return {...manifest,permissions};
+}

package/packages/block-sdk/port-types.js

@@ -83,7 +83,7 @@ export interface StillMadeModule {
   media: {transform(request: {operation: string; [key: string]: unknown}): Promise<StillMadeMedia | {sampleRate: number; duration: number; samples: Float32Array}>};
   actions: {run(action: {operation: string; request: Record<string, unknown>}): Promise<unknown>};
   hosted: {run(operation: string, request: Record<string, unknown>): Promise<unknown>};
-  net: {fetch(url: string | URL, init?: {method?: string; headers?: Record<string, string> | Array<[string, string]>; body?: ArrayBuffer | ArrayBufferView | Blob | string}): Promise<Response>};
+  net: {fetch(url: string | URL, init?: {method?: string; headers?: Record<string, string> | Array<[string, string]>; body?: ArrayBuffer | ArrayBufferView | Blob | string}): Promise<Response>; connect(url: string | URL, options?: {protocols?: string | string[]}): Promise<{url: string; protocol: string; readonly readyState: number; onmessage: ((event: {data: string | ArrayBuffer}) => void) | null; onclose: ((event: {code: number; reason: string; wasClean: boolean}) => void) | null; send(data: string | ArrayBuffer | ArrayBufferView | Blob): Promise<unknown>; close(code?: number, reason?: string): Promise<{code: number; reason: string; wasClean: boolean}>; closed: Promise<{code: number; reason: string; wasClean: boolean}>; addEventListener(type: 'message' | 'close', listener: (event: Event & Record<string, unknown>) => void): void; removeEventListener(type: 'message' | 'close', listener: (event: Event & Record<string, unknown>) => void): void; [Symbol.asyncIterator](): AsyncIterator<string | ArrayBuffer>}>};
   connections: {call(appId: string, operation: string, input?: Record<string, unknown>): Promise<unknown>};
   storage: {info(): Promise<Record<string, unknown>>; list(prefix?: string, options?: {after?: string}): Promise<{items: Array<{key: string; kind: 'value' | 'file'; bytes: number; mediaType: string; updatedAt: string}>; next?: string}>; get<T = unknown>(key: string): Promise<T | undefined>; set(key: string, value: unknown): Promise<unknown>; remove(key: string): Promise<{key: string; removed: boolean}>; putFile(key: string, data: ArrayBuffer | ArrayBufferView | Blob | string, options?: {mediaType?: string}): Promise<unknown>; getFile(key: string): Promise<{key: string; mediaType: string; bytes: number; data: ArrayBuffer} | null>};
   project: {read(fields?: string[]): Promise<Record<string, unknown>>};

package/packages/block-sdk/schema-fields.js

@@ -21,16 +21,19 @@ export function createSchemaFields(lockedInputKeys=[]) {
   const kept=second&&first.length+second.length<280?first+' '+second:first;
   return kept.length>280?kept.slice(0,279).trimEnd()+'…':kept;
  }
- function controls(schema,bindings,values,{canEdit=true,busy=false}={}) {
+ function controls(schema,bindings,values,{canEdit=true,busy=false,more=[],hide=[]}={}) {
   inert(schema);inert(bindings);inert(values);let count=0;const tree=[],actions=[];
   const action=(kind,path,s)=>{const id=`field-${actions.length}`;actions.push({id,kind,path,s});return id;};
+  // A single value is a Block kit field (label row and control); a group or list stays a plain section.
+  const fieldSection=(s,children)=>({tag:'section',...(s.type==='object'&&s.properties||s.type==='array'?{}:{className:'sm-field'}),children});
   function fields(s,path,value,label,required,depth) {
    if(++count>150||depth>5)return [{tag:'p',text:'This task needs a custom interface for its remaining fields.'}];
    // A description sits behind an (i) beside its label, one or two sentences:
    // connected apps describe fields at length for AI models, not people.
-   const name=String(label).slice(0,240)+(required?' *':' (optional)'),about=hint(s.description);
+   // A required field carries a star; most app fields are optional, so they say nothing (October 24, 2026).
+   const name=String(label).slice(0,240)+(required?' *':''),about=hint(s.description);
    const result=[about?{tag:'div',className:'sm-label',children:[{tag:'label',text:name},{tag:'details',className:'sm-hint',children:[{tag:'summary',label:'About '+String(label).slice(0,200)},{tag:'p',text:about}]}]}:{tag:'label',text:name}],disabled=busy||!canEdit||locked.has(path[0]);
-   if(s.type==='object'&&s.properties){for(const key of Object.keys(s.properties))result.push({tag:'section',children:fields(s.properties[key],path.concat(key),value?.[key],s.properties[key].title||key,(s.required||[]).includes(key),depth+1)});}
+   if(s.type==='object'&&s.properties){for(const key of Object.keys(s.properties))result.push(fieldSection(s.properties[key],fields(s.properties[key],path.concat(key),value?.[key],s.properties[key].title||key,(s.required||[]).includes(key),depth+1)));}
    else if(s.type==='array'){
     const rows=Array.isArray(value)?value:[];
     rows.slice(0,20).forEach((item,index)=>result.push({tag:'section',className:'connection-array',children:fields(s.items||{},path.concat(index),item,'Item '+(index+1),true,depth+1).concat([{tag:'button',text:'Remove item',action:action('remove',path.concat(index),s),disabled}])}));
@@ -43,7 +46,11 @@ export function createSchemaFields(lockedInputKeys=[]) {
    else result.push({tag:'p',text:'Select a compatible upstream value for this field.'});
    return result;
   }
-  for(const [port,field] of Object.entries(bindings)){const s=schema.properties?.[field];if(!s)throw Error('Choose a schema-declared input.');tree.push({tag:'section',children:fields(s,[port],values[port],s.title||field,(schema.required||[]).includes(field),0)});}
+  // Fields a Block names in `more` fold into a closed More options; fields in `hide` (an app's paging or
+  // debugging settings) are not shown and keep their defaults. A required field is always shown.
+  const folded=[];
+  for(const [port,field] of Object.entries(bindings)){const s=schema.properties?.[field];if(!s)throw Error('Choose a schema-declared input.');const required=(schema.required||[]).includes(field);if(!required&&Array.isArray(hide)&&hide.includes(field))continue;const section=fieldSection(s,fields(s,[port],values[port],s.title||field,required,0));(Array.isArray(more)&&more.includes(field)&&!required?folded:tree).push(section);}
+  if(folded.length)tree.push({tag:'details',className:'sm-more',children:[{tag:'summary',text:`More options · ${folded.length}`},...folded]});
   return {tree,actions};
  }
  function change(values,actions,event) {

package/packages/block-sdk/testing.js

@@ -11,6 +11,7 @@ import {validateComfyWorkflow,validateComfyExpectations,testComfyOutputs} from '
 import {CAPABILITY_LIMITS,validateCapability,prepareCapabilityInvocation,validateCapabilityExpectations,testCapabilityOutputs} from './capabilities.js';
 import {validateNativeApplicationPackage,NATIVE_APPLICATION_RUNTIME_REQUIREMENT} from './native-application-package.js';
 import {validateModuleDescriptor,MODULE_LIMITS} from './module-runtime.js';
+import {validateMocks} from './mocks.js';
 export function validatePackage(pkg) {
   safeDocument(pkg);
   if(pkg?.manifest?.runtime==='native-application')return validateNativeApplicationPackage(pkg);
@@ -49,9 +50,12 @@ export function validatePackage(pkg) {
     validateValues(pkg.manifest.inputs,fixture.input);
     validateComfyExpectations(pkg.manifest,fixture.expectations);
   }
+  // A module fixture may record what the host answers (mocks, the tests/mocks.json shape): the
+  // hosted calls, actions and transforms it makes then cost nothing and give the same result each run.
   if(pkg.manifest.runtime === 'module')for(const fixture of pkg.tests){
-    assert(fixture&&typeof fixture.name==='string'&&fixture.name.trim().length>0&&fixture.name.length<=200&&Object.keys(fixture).every(key=>['name','input','expected'].includes(key)),'TEST','Module fixtures need a name, input and the exact expected outputs');
+    assert(fixture&&typeof fixture.name==='string'&&fixture.name.trim().length>0&&fixture.name.length<=200&&Object.keys(fixture).every(key=>['name','input','expected','mocks'].includes(key)),'TEST','Module fixtures need a name, input and the exact expected outputs, and may record mocks');
     validateValues(pkg.manifest.inputs,fixture.input);validateValues(pkg.manifest.outputs,fixture.expected,'output');
+    if(fixture.mocks!==undefined)validateMocks(fixture.mocks);
   }
   if(pkg.manifest.runtime === 'capability'){
     assert(pkg.tests.length<=CAPABILITY_LIMITS.fixtures,'TESTS_REQUIRED','Include 1–3 explicitly approved remote fixtures');
@@ -69,7 +73,10 @@ export function validatePackage(pkg) {
   validatePortableMetadata(pkg);
   return true;
 }
-export async function testPackage(pkg, { timeoutMs = 10000, wasmLocation, comfyui, capability, desktop, module } = {}) {
+// moduleFor(fixture): the module executor for one fixture (one answering its recorded mocks), in place of `module`.
+// onTest hears each fixture start and end ({phase, index, total, name, passed}), so a review can show the test
+// that is running; the returned results stay the only verdict.
+export async function testPackage(pkg, { timeoutMs = 10000, wasmLocation, comfyui, capability, desktop, module, moduleFor, onTest } = {}) {
   validatePackage(pkg);
   assert(pkg.manifest.runtime!=='native-application','NATIVE_APPLICATION_RUNTIME_UNAVAILABLE',NATIVE_APPLICATION_RUNTIME_REQUIREMENT);
   const results = [];
@@ -77,24 +84,30 @@ export async function testPackage(pkg, { timeoutMs = 10000, wasmLocation, comfyu
   const ceiling = pkg.manifest.runtime === 'module' ? MODULE_LIMITS.wallClockMs : 10000;
   const budget = Math.max(0, Math.min(ceiling, Number.isFinite(timeoutMs) ? timeoutMs : 10000));
   const deadline = Date.now() + budget;
-  for (const test of pkg.tests) {
+  const tell = event => { try { onTest?.(event); } catch {} }, total = pkg.tests.length;
+  for (const [index, test] of pkg.tests.entries()) {
+    tell({ phase: 'start', index, total, name: test?.name || 'Unnamed' });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.max(0, deadline - Date.now()));
     try {
       assert(Date.now() < deadline, 'TIMEOUT', 'Fixture suite exceeded its time budget');
       assert(typeof test.name === 'string' && test.name.length > 0, 'TEST', 'A test needs a name');
-      const { outputs, metadata, state } = await runPackageAsync(pkg, test.input, { signal: controller.signal, wasmLocation, comfyui, capability, desktop, module,...(pkg.manifest.state?{state:test.state??initialBlockState(pkg.manifest)}:{}) });
+      const { outputs, metadata, state, logs } = await runPackageAsync(pkg, test.input, { signal: controller.signal, wasmLocation, comfyui, capability, desktop, module:typeof moduleFor==='function'?moduleFor(test):module,...(pkg.manifest.state?{state:test.state??initialBlockState(pkg.manifest)}:{}) });
       assert(Date.now() < deadline, 'TIMEOUT', 'Fixture suite exceeded its time budget');
       if(pkg.manifest.runtime === 'comfyui')testComfyOutputs(pkg.manifest,outputs,test.expectations,{metadata});
       else if(pkg.manifest.runtime === 'capability')testCapabilityOutputs(pkg.manifest,outputs,test.expectations);
       else {
         const actual=stableStringify(outputs),expected=stableStringify(test.expected);
-        assert(actual===expected,'BEHAVIOR',`Output differs from expected fixture. Expected ${expected.slice(0,1200)}; received ${actual.slice(0,1200)}`);
+        // Each output that differs, with both values, so a long output (a transcript) never hides the
+        // one that differs; a module's failed host calls (in its log) say why (October 22, 2026).
+        const differing=[...new Set([...Object.keys(test.expected||{}),...Object.keys(outputs||{})])].filter(key=>stableStringify(outputs?.[key])!==stableStringify(test.expected?.[key]));
+        const failedCalls=(logs||[]).filter(line=>/ failed: /.test(line)).slice(0,3);
+        assert(actual===expected,'BEHAVIOR',`Output differs from expected fixture${differing.length?` in ${differing.join(', ')}`:''}. ${differing.length?differing.slice(0,4).map(key=>`${key}: expected ${String(stableStringify(test.expected?.[key])).slice(0,600)}; received ${String(stableStringify(outputs?.[key])).slice(0,600)}`).join('. '):`Expected ${expected.slice(0,1200)}; received ${actual.slice(0,1200)}`}${failedCalls.length?`. Host calls that failed: ${failedCalls.join('; ')}`:''}`);
       }
       if(pkg.manifest.state)assert(stableStringify(state)===stableStringify(test.expectedState),'STATE_BEHAVIOR','State differs from expected fixture');
       results.push({ name: test.name, passed: true });
     } catch (e) { results.push({ name: test?.name || 'Unnamed', passed: false, code: controller.signal.aborted ? 'TIMEOUT' : e.code || 'TEST', message: controller.signal.aborted ? 'Fixture suite exceeded its time budget' : e.message }); }
-    finally { clearTimeout(timer); }
+    finally { clearTimeout(timer); const result = results.at(-1); tell({ phase: 'end', index, total, name: result.name, passed: result.passed, ...(result.passed ? {} : { code: result.code, message: result.message }) }); }
   }
-  return { digest: await digest(pkg), sdkVersion: '0.1.0', passed: results.every(r => r.passed), results,...(requiresDesktopExecution(pkg)?{execution:typeof desktop==='function'?'desktop-host-executor':'unavailable',liveVerified:false,reviewRequired:true}:pkg.manifest.runtime==='module'?{execution:typeof module==='function'?'module-executor':'unavailable',reviewRequired:typeof module!=='function'}:pkg.manifest.runtime==='capability'?{execution:typeof capability==='function'?'host-executor':'unavailable',liveVerified:false,reviewRequired:true}:{}) };
+  return { digest: await digest(pkg), sdkVersion: '0.1.0', passed: results.every(r => r.passed), results,...(requiresDesktopExecution(pkg)?{execution:typeof desktop==='function'?'desktop-host-executor':'unavailable',liveVerified:false,reviewRequired:true}:pkg.manifest.runtime==='module'?{execution:typeof module==='function'||typeof moduleFor==='function'?'module-executor':'unavailable',reviewRequired:typeof module!=='function'&&typeof moduleFor!=='function'}:pkg.manifest.runtime==='capability'?{execution:typeof capability==='function'?'host-executor':'unavailable',liveVerified:false,reviewRequired:true}:{}) };
 }

package/packages/block-sdk/view-bridge.js

@@ -30,6 +30,7 @@ export const VIEW_BRIDGE=Object.freeze([
  {name:'previewMedia',group:'Media',signature:'previewMedia(value: StillMadeVideo | StillMadeAudio): Promise<{kind: "video" | "audio"; url: string}>',summary:'A playable blob: URL for audio or video the view may play. Call releaseMedia when done.',where:all},
  {name:'releaseMedia',group:'Media',signature:'releaseMedia(url: string): void',summary:'Frees a URL previewMedia returned.',where:all},
  {name:'asset',group:'Media',signature:'asset(path: string): string',summary:'A blob: URL for one of the view\'s own asset files, for <img>, new FontFace() or <video>.',where:frame},
+ {name:'live',group:'Media',signature:'readonly live: {start(options: {camera?: boolean; microphone?: boolean; fps?: number; width?: number; sampleRate?: number}): Promise<{live: true; camera: boolean; microphone: boolean; fps: number; width: number; height: number; sampleRate: number}>; stop(): Promise<{live: false}>; status(): Promise<{live: boolean; [key: string]: unknown}>; onFrame(callback: (frame: ImageBitmap, info: {index: number; timestamp: number; width: number; height: number}) => void): () => void; onAudio(callback: (samples: Float32Array, info: {index: number; timestamp: number; sampleRate: number}) => void): () => void; onEnd(callback: (event: {reason: string}) => void): () => void}',summary:'The camera, the microphone or both as they happen (declare camera.capture and microphone.capture). Nothing reaches the view until the person presses Start in StillMade, which then shows that the device is on and a Turn off button. Frames arrive as ImageBitmaps, closed when your callback returns, so draw or copy them there; a slow view gets fewer frames, never a backlog. Audio arrives as mono Float32Array chunks. Nothing is saved. In browsers and StillMade Desktop.',where:all},
  {name:'assetBytes',group:'Media',signature:'assetBytes(path: string): ArrayBuffer',summary:'A copy of one of the view\'s own asset files.',where:frame},
  // Generated interface
  {name:'render',group:'Generated interface',signature:'render(targetId: string, tree: Array<Record<string, unknown>>): void',summary:'Renders a tree of StillMade controls into an element, for standard views that build their interface from data.',where:all},
@@ -40,7 +41,7 @@ export const VIEW_BRIDGE=Object.freeze([
  {name:'onSharedWorkRefresh',group:'Connected work',signature:'onSharedWorkRefresh(callback: () => void): () => void',summary:'Called when shared work changes elsewhere; read it again.',where:saved},
  {name:'previewSharedWorkMedia',group:'Connected work',signature:'previewSharedWorkMedia(contributionId: string): Promise<{url: string; kind: "image" | "video" | "audio"}>',summary:'A display copy of media attached to a shared work contribution.',where:saved},
  {name:'releaseSharedWorkMedia',group:'Connected work',signature:'releaseSharedWorkMedia(url: string): void',summary:'Frees a URL previewSharedWorkMedia returned.',where:saved},
- {name:'desktop',group:'Connected work',signature:'desktop(operation: string, args?: Record<string, unknown>): Promise<Record<string, unknown>>',summary:'Runs a declared desktop permission after the person grants it. Recording (record.start, record.stop, record.cancel, record.status) and cutting a recording (record.cut) work in browsers and in StillMade Desktop; clipboard, media.pick, notifications, keep-awake and native tools need StillMade Desktop.',where:`${all} for recording; ${desktop} for the rest`},
+ {name:'desktop',group:'Connected work',signature:'desktop(operation: string, args?: Record<string, unknown>): Promise<Record<string, unknown>>',summary:'Runs a declared desktop permission after the person grants it. Recording (record.start, record.stop, record.cancel, record.status), cutting a recording (record.cut) and folders the person picks (folder.*; Chrome and Edge in a browser) work in browsers and in StillMade Desktop; clipboard, media.pick, notifications, keep-awake and native tools need StillMade Desktop. Picking or pressing Start is the consent; StillMade asks once only about the clipboard, the cursor and desktop programs.',where:`${all} for recording and folders; ${desktop} for the rest`},
 ]);
 export const VIEW_BRIDGE_MEMBERS=Object.freeze(VIEW_BRIDGE.map(member=>member.name));
 

package/blocks/connected-app/versions/1.5.0/view.js

@@ -1,18 +0,0 @@
-import {taskSelectionView} from './task-selection.js';
-import {connectedAppView as originalView} from '../1.0.0/view.js';
-import {metaTestView,metaTestContract} from '../../../meta-ads/versions/1.2.0/workspace.js';
-import {gmailWorkspaceView} from '../../../gmail/versions/1.0.0/workspace.js';
-// Result tables from the shared preview: scroll sideways instead of squeezing.
-const RESULT_CSS='.connection-table{overflow-x:auto;display:grid;gap:4px}#connection-result table{border-collapse:collapse;width:100%;font-size:14px}#connection-result th,#connection-result td{text-align:left;vertical-align:top;padding:6px 8px;border-bottom:1px solid var(--border);overflow-wrap:break-word}#connection-result thead th{font-weight:600;white-space:nowrap}.connection-fields th{width:35%;font-weight:500}#connection-result details{border-top:1px solid var(--border);padding:6px 0}#connection-result summary{cursor:pointer;font-weight:500}';
-export function connectedAppWorkspace(appId,schema,bindings){
- if(appId==='app:meta-ads')return {sharedWork:metaTestContract,view:metaTestView()};
- if(appId==='app:gmail')return gmailWorkspaceView(schema,bindings);
- return {};
-}
-export function connectedAppView(schema,bindings,{appId}={}){
- const workspace=connectedAppWorkspace(appId,schema,bindings),view=originalView(workspace.schema||schema,bindings);
- view.javascript=view.javascript.replace('canEdit=true','canEdit=false').replace("[{tag:'h3',text:'Result'},{tag:'output',className:'connection-result',text:JSON.stringify(shared.outputs.result,null,2).slice(0,10000)}]",'StillMade.schemaFields.preview(shared.outputs.result)');
- if(workspace.view){view.html=workspace.view.html+view.html;view.css=workspace.view.css+'\n'+view.css;view.javascript+='\n'+workspace.view.javascript;}
- if(workspace.heading){view.html='<header><h2>'+workspace.heading+'</h2><p>'+workspace.description+'</p></header>'+view.html;view.html=view.html.replace('Review and run task',workspace.runLabel);}
- const tasks=taskSelectionView();view.javascript=view.javascript.replace('if(busy||!canEdit)return;try{draft=StillMade.schemaFields.change','if(busy||!canEdit||!actions.some(item=>item.id===event.action))return;try{draft=StillMade.schemaFields.change');return {html:tasks.html+view.html,css:tasks.css+'\n'+view.css+'\n'+RESULT_CSS,javascript:view.javascript+'\n'+tasks.javascript};
-}

package/blocks/gmail/versions/1.0.0/workspace.js

@@ -1,6 +0,0 @@
-// Draft controls remain in the existing project-local view state. Reusing a
-// mailbox grants neither cross-project draft access nor permission to send.
-export function gmailWorkspaceView(schema,bindings){
- const fieldNames=Object.keys(schema.properties||{}),known=['to','recipient','recipients','subject','body','text_body','html_body','thread_id','threadId'],ordered=[...known.filter(key=>fieldNames.includes(key)),...fieldNames.filter(key=>!known.includes(key))],copy={...schema,properties:Object.fromEntries(ordered.map(key=>[key,{...schema.properties[key],title:({to:'To',recipient:'To',recipients:'To',subject:'Subject',body:'Message',text_body:'Message',html_body:'HTML message',thread_id:'Selected thread',threadId:'Selected thread'})[key]||schema.properties[key].title||key}]))};
- return {schema:copy,heading:'Email workspace',description:'Keep this project’s selected thread and draft here. Reusing your mailbox in another project keeps its draft separate. Reading or attaching a thread never authorizes sending.',runLabel:'Review email task'};
-}