stillmade-sdk 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stillmade-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "StillMade Block SDK, CLI and examples",
   "license": "PolyForm-Shield-1.0.0",
   "type": "module",

package/packages/block-cli/cli.js

@@ -37,6 +37,7 @@ import { validateProjectType } from '../block-platform/project-types.js';
 import { testProjectType } from '../block-platform/type-testing.js';
 import {previewProjectType} from '../block-platform/type-preview.js';
 import {assessBlockReadiness} from '../block-platform/block-readiness.js';
+import {defineBrowserApplicationSource} from '../block-sdk/browser-application-execution.js';
 import { BUILTIN_BLOCKS } from '../block-platform/catalog.js';
 import { RECIPE_TYPE_EXAMPLE, typeWorkspaceSupport } from '../block-platform/type-workspace.js';
 import {PLATFORM_CHECK_POLICY,PLATFORM_CHECK_TARGETS,PLATFORM_CHECK_THEMES} from '../block-sdk/platform-checks.js';
@@ -206,7 +207,15 @@ export async function main(rawArgs) {
     await mkdir(path,{recursive:true});
     const names=['stillmade.block.json',...Object.keys(files).filter(name=>name!=='stillmade.block.json')];
     for(const name of names){await mkdir(dirname(join(path,name)),{recursive:true});await writeFile(join(path,name),files[name],{flag:'wx'});}
-    return { created: path, sdkVersion: '0.1.0', template:template.name, runtime:template.runtime, files:names };
+    // Coding agents read command output: restate the readiness rule where they will see it.
+    return { created: path, sdkVersion: '0.1.0', template:template.name, runtime:template.runtime, files:names, next: 'Build the Block, then run `stillmade-block gate .`. Do not call the Block ready until the gate passes; report the status it prints.' };
+  }
+  if (command === 'gate') {
+    // Every new or edited Block in a folder must pass readiness before anyone calls it ready.
+    const {runReadyGate,gateMessage}=await import('./ready-gate.js');
+    const verdict=await runReadyGate({root:path,main});
+    if(!verdict.passed)throw Object.assign(new Error(gateMessage(verdict)),{code:'READINESS_GATE_FAILED',report:{results:verdict.results}});
+    return {passed:true,checked:verdict.checked,results:verdict.results.map(({package:name,status,limitations})=>({package:name,status,limitations}))};
   }
   if(command==='run')return main(['preview',...args.slice(1),...(mockRequested?['--mock']:[])]);
   if(command==='dev')return dev(path,args.slice(2));
@@ -226,6 +235,12 @@ export async function main(rawArgs) {
   if(command==='ready'){
     // The same Block builder contract readiness check StillMade runs before a release.
     if(pkg.stages)throw new Error('ready checks one Block package; run it on each Block in the Project Type.');
+    if(pkg.manifest?.runtime==='browser-application'){
+      // An original browser application is judged only by StillMade's isolated
+      // review; locally its exact source contract is all that can be checked.
+      const source=await defineBrowserApplicationSource(pkg);
+      throw Object.assign(new Error(`${source.manifest.name} passed the local browser-application source contract. Browser applications are judged only by StillMade's isolated review: import this exact package in the StillMade desktop app and run its review. It is not ready until that review passes.`),{code:'APPLICATION_REVIEW_REQUIRED'});
+    }
     const readiness=await assessBlockReadiness(pkg);
     if(['FAILED','BLOCKED BY PLATFORM CAPABILITY'].includes(readiness.status))throw Object.assign(new Error(`Block readiness: ${readiness.status}`),{report:readiness});
     return readiness;

package/packages/block-cli/format.js

@@ -18,6 +18,8 @@ Build and check
   types [folder]               Write stillmade-env.d.ts: TypeScript types for the ports and globals
   inspect [folder]             Show the manifest, runtime and operations
   ready [folder]               The readiness check StillMade runs before a release
+  gate [folder]                Run ready on every new or edited Block in a folder; a Block is not
+                               ready until this passes
 
 Share
   pack [folder] [output]       Test, then write the file to import in StillMade (Create, then Import)

package/packages/block-cli/ready-gate.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+// Readiness gate for Blocks built outside StillMade. It runs StillMade's own
+// readiness check on every Block package in a folder that differs from what
+// the SDK shipped, so a coding agent (Claude Code, Cursor, Codex...) cannot
+// call a Block ready while that check fails. Results are cached by content
+// digest, so an unchanged Block is never re-run.
+import {createHash} from 'node:crypto';
+import {readFile,readdir,writeFile,mkdir,lstat} from 'node:fs/promises';
+import {realpathSync} from 'node:fs';
+import {join,relative,resolve,sep} from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+export const READY_GATE_STATE='.stillmade';
+// Shipped in the SDK download: Claude Code and Cursor run the gate whenever the
+// agent finishes a turn and hand any failures back to it.
+export const AGENT_READY_GATE_HOOKS=Object.freeze({
+ claude:{hooks:{Stop:[{hooks:[{type:'command',command:'node "$CLAUDE_PROJECT_DIR/packages/block-cli/ready-gate.js" --claude',timeout:600}]}]}},
+ cursor:{version:1,hooks:{stop:[{command:'node packages/block-cli/ready-gate.js --cursor',timeout:600}]}}
+});
+export const SDK_BASELINE_FILE='.stillmade/sdk-baseline.json';
+const SKIP=new Set(['node_modules','.git','.stillmade','.claude','.cursor','packages','dist','build','coverage']);
+const PASSING=new Set(['PRODUCTION READY','READY WITH DOCUMENTED LIMITATIONS','PROJECT TYPE TESTS PASSED']);
+const LIMITS=Object.freeze({directories:4000,depth:8,packageBytes:24*1024*1024});
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const posix=path=>path.split(sep).join('/');
+
+/** Digest of one package: a single file, or every file under a package folder. */
+export async function packageDigest(path){
+ const info=await lstat(path);
+ if(!info.isDirectory())return sha256(await readFile(path));
+ const hash=createHash('sha256'),files=[];let bytes=0;
+ const walk=async(folder,prefix='')=>{for(const entry of await readdir(folder,{withFileTypes:true})){
+  if(entry.isSymbolicLink())throw new Error(`Package symlinks are unavailable: ${prefix}${entry.name}`);
+  const full=join(folder,entry.name);
+  if(entry.isDirectory())await walk(full,prefix+entry.name+'/');
+  else if(entry.isFile())files.push([prefix+entry.name,full]);
+ }};
+ await walk(path);
+ files.sort(([a],[b])=>a<b?-1:a>b?1:0);
+ for(const [name,full] of files){const data=await readFile(full);bytes+=data.length;if(bytes>LIMITS.packageBytes)throw new Error('Package exceeds the readiness gate size limit');hash.update(name+'\0'+data.length+'\0');hash.update(data);}
+ return hash.digest('hex');
+}
+
+/** Block and Project Type packages under root: folders holding stillmade.block.json
+ * or portable.json, and single .stillmade.json / .stillmade-block files. */
+export async function findPackages(root){
+ const found=[];let visited=0;
+ const walk=async(folder,depth)=>{
+  if(++visited>LIMITS.directories||depth>LIMITS.depth)return;
+  const entries=await readdir(folder,{withFileTypes:true});
+  if(entries.some(entry=>entry.isFile()&&['stillmade.block.json','portable.json'].includes(entry.name))){found.push(folder);return;}
+  for(const entry of entries){
+   const full=join(folder,entry.name);
+   if(entry.isDirectory()&&!SKIP.has(entry.name)&&!entry.name.startsWith('.'))await walk(full,depth+1);
+   else if(entry.isFile()&&/\.(stillmade\.json|stillmade-block)$/i.test(entry.name))found.push(full);
+  }
+ };
+ await walk(root,0);
+ return found.sort();
+}
+
+/** Baseline of the packages an SDK download ships, so only new or edited
+ * Blocks are judged. Keys are POSIX paths relative to the SDK root. */
+export async function sdkBaseline(root){
+ const entries={};
+ for(const path of await findPackages(root))entries[posix(relative(root,path))]=await packageDigest(path);
+ return {version:1,packages:entries};
+}
+
+/** Baseline for an in-memory archive map, computed by the same rules on disk. */
+export async function sdkBaselineForFiles(files){
+ const {mkdtemp,rm}=await import('node:fs/promises'),{tmpdir}=await import('node:os'),{dirname}=await import('node:path');
+ const folder=await mkdtemp(join(tmpdir(),'stillmade-sdk-baseline-'));
+ try{
+  for(const [name,bytes] of Object.entries(files)){if(name.endsWith('/'))continue;const target=join(folder,...name.split('/'));await mkdir(dirname(target),{recursive:true});await writeFile(target,bytes);}
+  return await sdkBaseline(folder);
+ }finally{await rm(folder,{recursive:true,force:true});}
+}
+
+async function readJson(path,fallback){try{return JSON.parse(await readFile(path,'utf8'));}catch{return fallback;}}
+const summarize=readiness=>(readiness?.items||[]).filter(item=>['failed','blocked'].includes(item.state)).slice(0,6).map(item=>`${item.id} ${item.title}: ${String(item.reason||'').slice(0,300)}`);
+
+async function judge(path,main){
+ try{
+  const readiness=await main(['ready',path]);
+  return {ok:PASSING.has(readiness.status),status:readiness.status,failures:summarize(readiness),limitations:(readiness.limitations||[]).length};
+ }catch(error){
+  if(/^ready checks one Block package/.test(error.message)){
+   try{await main(['test',path]);return {ok:true,status:'PROJECT TYPE TESTS PASSED',failures:[]};}
+   catch(typeError){return {ok:false,status:'FAILED',failures:[String(typeError.message).slice(0,300)]};}
+  }
+  if(error.code==='APPLICATION_REVIEW_REQUIRED')return {ok:false,status:'NEEDS STILLMADE REVIEW',failures:[String(error.message).slice(0,400)]};
+  if(error.report?.status)return {ok:false,status:error.report.status,failures:summarize(error.report)};
+  return {ok:false,status:'FAILED',failures:[String(error.message).slice(0,300)]};
+ }
+}
+
+/** Judge every changed package. Never throws for a failing Block; returns a verdict. */
+export async function runReadyGate({root=process.cwd(),main}={}){
+ root=resolve(root);
+ main??=(await import('./cli.js')).main;
+ const baseline=(await readJson(join(root,SDK_BASELINE_FILE),{packages:{}})).packages||{};
+ const cachePath=join(root,READY_GATE_STATE,'ready-cache.json'),cache=await readJson(cachePath,{version:1,entries:{}});
+ const results=[];
+ for(const path of await findPackages(root)){
+  const name=posix(relative(root,path)),digest=await packageDigest(path);
+  if(baseline[name]===digest)continue;
+  const cached=cache.entries[name];
+  const verdict=cached?.digest===digest?cached:{digest,...await judge(path,main),checkedAt:new Date().toISOString()};
+  cache.entries[name]=verdict;
+  results.push({package:name,...verdict});
+ }
+ await mkdir(join(root,READY_GATE_STATE),{recursive:true});
+ await writeFile(cachePath,JSON.stringify(cache,null,1)+'\n');
+ const failing=results.filter(result=>!result.ok);
+ return {checked:results.length,passed:failing.length===0,results,failing,signature:sha256(JSON.stringify(failing.map(result=>[result.package,result.digest])))};
+}
+
+export function gateMessage(verdict){
+ const lines=verdict.failing.map(result=>`- ${result.package} (${result.status}):\n${result.failures.map(failure=>`    ${failure}`).join('\n')||'    readiness check failed'}`);
+ return `StillMade readiness gate: ${verdict.failing.length} Block${verdict.failing.length===1?'':'s'} you changed ${verdict.failing.length===1?'is':'are'} not ready.\n${lines.join('\n')}\nFix these and re-run \`node packages/block-cli/cli.js ready <folder>\`. Do not tell the user a Block is ready, done or working while this gate fails. If you cannot fix it, say plainly that the Block is NOT ready and list these failures.`;
+}
+
+/** Hook entry. `agent` is claude, cursor or plain. Returns {exitCode, stdout}. */
+export async function readyGateHook({agent='plain',input={},root,main}={}){
+ root=resolve(root||(agent==='cursor'?process.env.CURSOR_PROJECT_DIR||input.workspace_roots?.[0]:process.env.CLAUDE_PROJECT_DIR||input.cwd)||process.cwd());
+ const verdict=await runReadyGate({root,main});
+ const statePath=join(root,READY_GATE_STATE,'gate-state.json'),state=await readJson(statePath,{});
+ if(verdict.passed){
+  await writeFile(statePath,'{}\n');
+  return {exitCode:0,stdout:agent==='plain'?JSON.stringify({passed:true,checked:verdict.checked,results:verdict.results.map(({package:name,status})=>({package:name,status}))},null,2)+'\n':agent==='cursor'?'{}\n':''};
+ }
+ // An agent that already saw this exact failure set and made no change may
+ // stop (it has been told to report the Block as not ready); any edit re-arms.
+ const repeated=state.signature===verdict.signature;
+ if(agent==='claude'){
+  if(input.stop_hook_active&&repeated)return {exitCode:0,stdout:''};
+  await writeFile(statePath,JSON.stringify({signature:verdict.signature})+'\n');
+  return {exitCode:0,stdout:JSON.stringify({decision:'block',reason:gateMessage(verdict)})+'\n'};
+ }
+ if(agent==='cursor'){
+  if(Number(input.loop_count)>0&&repeated)return {exitCode:0,stdout:'{}\n'};
+  await writeFile(statePath,JSON.stringify({signature:verdict.signature})+'\n');
+  return {exitCode:0,stdout:JSON.stringify({followup_message:gateMessage(verdict)})+'\n'};
+ }
+ return {exitCode:1,stdout:gateMessage(verdict)+'\n'};
+}
+
+if(process.argv[1]&&(()=>{try{return realpathSync(process.argv[1])===fileURLToPath(import.meta.url);}catch{return false;}})()){
+ const agent=process.argv.includes('--claude')?'claude':process.argv.includes('--cursor')?'cursor':'plain';
+ let raw='';
+ if(agent!=='plain'&&!process.stdin.isTTY){for await(const chunk of process.stdin)raw+=chunk;}
+ let input={};try{input=raw.trim()?JSON.parse(raw):{};}catch{}
+ const rootArg=process.argv.slice(2).find(arg=>!arg.startsWith('--'));
+ readyGateHook({agent,input,root:rootArg}).then(({exitCode,stdout})=>{process.stdout.write(stdout);process.exitCode=exitCode;})
+  .catch(error=>{
+   const message=`StillMade readiness gate could not run: ${error.message}. Run \`node packages/block-cli/cli.js ready <folder>\` yourself before telling the user a Block is ready.`;
+   if(agent==='claude'&&!input.stop_hook_active)process.stdout.write(JSON.stringify({decision:'block',reason:message})+'\n');
+   else if(agent==='cursor'&&!(Number(input.loop_count)>0))process.stdout.write(JSON.stringify({followup_message:message})+'\n');
+   else process.stderr.write(message+'\n');
+   process.exitCode=agent==='plain'?1:0;
+  });
+}

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

@@ -5,7 +5,7 @@
 // Project Type) and maps everything onto the builder contract's Definition of
 // Done. Status is derived, never asserted: an item that did not run is
 // "not-verified", so the report cannot claim more than was checked.
-import {BUILDER_CONTRACT,READINESS_STATUSES,GAP_CLASSES} from '../block-sdk/builder-contract.js';
+import {BUILDER_CONTRACT,READINESS_STATUSES,GAP_CLASSES,BLOCK_NAME_MAX_LENGTH} from '../block-sdk/builder-contract.js';
 import {compatible,digest,stableStringify,validateBlockOutputs} from '../block-sdk/contracts.js';
 import {validatePackage} from '../block-sdk/testing.js';
 import {admitLocalPackage} from '../block-sdk/local-admission.js';
@@ -23,7 +23,7 @@ const OFFLINE_RUNTIMES=new Set(['recipe','javascript']);
 // Conditions of the checking machine, not of the Block: they leave items unverified, never failed.
 const ENVIRONMENT=new Set(['BUSY','READINESS_BUDGET','TIMEOUT_BUDGET']);
 const environmental=entry=>ENVIRONMENT.has(entry?.code)||/runners are busy/i.test(entry?.message||'');
-const HOST_REFUSALS=Object.freeze({RUNTIME_UNAVAILABLE:'E',DESKTOP_EXECUTION_REQUIRED:'E',LOCAL_WORKER_REQUIRED:'E'});
+const HOST_REFUSALS=Object.freeze({RUNTIME_UNAVAILABLE:'E',DESKTOP_EXECUTION_REQUIRED:'E',LOCAL_WORKER_REQUIRED:'E',NATIVE_APPLICATION_RUNTIME_UNAVAILABLE:'E'});
 const TITLES=Object.fromEntries(BUILDER_CONTRACT.definitionOfDone.map(item=>[item.id,item.title]));
 const message=error=>String(error?.message||error).slice(0,300);
 const offline=pkg=>OFFLINE_RUNTIMES.has(pkg?.manifest?.runtime)&&!requiresDesktopExecution(pkg);
@@ -98,6 +98,7 @@ export async function assessBlockReadiness(pkg,{catalog=FIRST_PARTY_SDK_PACKAGES
  }
  try{validatePackage(pkg);verified('DOD-02','Manifest, ports and fixtures validate against the SDK schema.');}
  catch(error){failed('DOD-02',message(error));return result();}
+ if(pkg.manifest.name.trim().length>BLOCK_NAME_MAX_LENGTH)failed('DOD-02',`Shorten the Block name to ${BLOCK_NAME_MAX_LENGTH} characters or fewer. Put the detail in its description.`);
 
  const manifest=pkg.manifest,sourceDigest=await digest(pkg),hosted=!offline(pkg);
  let report=admission;

package/packages/block-platform/canvas.js

@@ -115,7 +115,7 @@ export function connectedBlockInputs(node, nodes, edges, {context={},raw=false,a
     }
     if(!pin&&allowOmissions && source.type==='programmableBlockNode' && !source.data.blockStale && output.required===false && node.data?.blockPackage?.manifest?.inputs[name]?.required===false && source.data.blockOutputs && !Object.hasOwn(source.data.blockOutputs,output.name) && /^[a-f0-9]{64}$/.test(source.data.blockDigest || '') && source.data.blockLastRun?.digest===source.data.blockDigest && Number.isFinite(Date.parse(source.data.blockLastRun.at))){omissions[name]=true;continue;}
     inputs[name] = pinnedOutput.value;
-    if (pinnedOutput.value === undefined){errors.push(pin?`The pinned result for ${name} is unavailable. Choose a recorded result again.`:`Run the upstream block for ${name} first`);continue;}
+    if (pinnedOutput.value === undefined){errors.push(pin?`The pinned result for ${name} is unavailable. Choose a recorded result again.`:`Run ${source?.data?.label||source?.data?.blockPackage?.manifest?.name||'the Step before this one'} first.`);continue;}
     if(node.type==='programmableBlockNode' && !raw){
      try{inputs[name]=adaptConnectionValue(pinnedOutput,node.data.blockPackage.manifest.inputs[name],pinnedOutput.value,{context,semantics,permissions:node.data.blockPackage.manifest.permissions?.project || [],...(Object.hasOwn(edge.data || {},'stillmadeAdapter')?{adapter:edge.data.stillmadeAdapter}:{})});}
      catch(error){inputs[name]=undefined;errors.push(error.message);}

package/packages/block-platform/catalog.js

@@ -1,5 +1,5 @@
 import {REVENUE_REVIEW_PROJECT_TYPES} from './revenue-review-project-types.js';
-import {PRODUCT_AD_VARIANTS_PROJECT_TYPE,PRIOR_PRODUCT_AD_VARIANTS_PROJECT_TYPE,PREVIOUS_PRODUCT_AD_VARIANTS_PROJECT_TYPE} from './product-ad-variants-project-type.js';
+import {PRODUCT_AD_VARIANTS_PROJECT_TYPE,PRODUCT_AD_VARIANTS_PROJECT_TYPE_1_0_3,PRIOR_PRODUCT_AD_VARIANTS_PROJECT_TYPE,PREVIOUS_PRODUCT_AD_VARIANTS_PROJECT_TYPE} from './product-ad-variants-project-type.js';
 import {FIRST_PARTY_SDK_PACKAGES} from '../block-sdk/first-party-packages.js';
 import {FIRST_REVENUE_PROJECT_TYPES} from './first-revenue-project-types.js';
 import { SDK_VERSION, ROOT_CHAT_ID } from '../block-sdk/contracts.js';
@@ -86,7 +86,7 @@ HOST_WORKSPACE_BLOCKS.splice(HOST_WORKSPACE_BLOCKS.findIndex(block=>block.manife
 // Promote a portable workspace after its accepted production MVP and rendered
 // acceptance are complete; advanced host extensions can remain on old exact pins. Exact portable releases remain usable as normal
 // Steps before promotion; this map only controls the default production route.
-export const CURRENT_PORTABLE_WORKSPACE_VERSIONS=Object.freeze({'sm.chat':'2.0.3','sm.script':'2.1.4','sm.voiceover':'2.1.4','sm.shot-plan':'2.1.3','sm.blueprint':'2.1.9','sm.pipeline':'2.2.5','sm.video-assets':'2.1.4','sm.panel-strip':'2.3.7','sm.board-editor':'2.2.10','sm.animated-scene':'2.3.8','sm.editor':'2.2.11'});
+export const CURRENT_PORTABLE_WORKSPACE_VERSIONS=Object.freeze({'sm.chat':'2.0.3','sm.script':'2.1.4','sm.voiceover':'2.1.6','sm.shot-plan':'2.1.3','sm.blueprint':'2.1.9','sm.pipeline':'2.2.5','sm.video-assets':'2.1.4','sm.panel-strip':'2.3.7','sm.board-editor':'2.2.10','sm.animated-scene':'2.3.8','sm.editor':'2.2.11'});
 export const WORKSPACE_BLOCKS=HOST_WORKSPACE_BLOCKS.map(block=>{
  const version=CURRENT_PORTABLE_WORKSPACE_VERSIONS[block.manifest.id];
  if(!version)return block;
@@ -122,7 +122,9 @@ const GENERATION_HOST_RELEASES=Object.freeze(['sm.generate-image','sm.generate-v
 const semverParts=version=>String(version).split(/[.-]/).slice(0,3).map(value=>Number(value)||0);
 const newer=(left,right)=>{const a=semverParts(left),b=semverParts(right);for(let i=0;i<3;i++){if(a[i]!==b[i])return a[i]>b[i];}return false;};
 const currentPortableById=new Map();
-for(const block of SDK_BUILTIN_BLOCKS){const prior=currentPortableById.get(block.manifest.id);if(!prior||newer(block.manifest.version,prior.manifest.version))currentPortableById.set(block.manifest.id,block);}
+// An unset app connector is a project placeholder, not something to find or install.
+export const UNDISCOVERABLE_SDK_BLOCKS=new Set(['sm.connect-app']);
+for(const block of SDK_BUILTIN_BLOCKS){if(UNDISCOVERABLE_SDK_BLOCKS.has(block.manifest.id))continue;const prior=currentPortableById.get(block.manifest.id);if(!prior||newer(block.manifest.version,prior.manifest.version))currentPortableById.set(block.manifest.id,block);}
 export const DISCOVERABLE_SDK_BUILTIN_BLOCKS = Object.freeze([...currentPortableById.values()]);
 export const DISCOVERABLE_BLOCKS = [STARTING_CHAT_BLOCK,...WORKSPACE_BLOCKS,...DISCOVERABLE_SDK_BUILTIN_BLOCKS.filter(block=>!WORKSPACE_BLOCKS.some(current=>current.manifest.id===block.manifest.id&&current.manifest.version===block.manifest.version))];
 export const BUILTIN_BLOCKS = [STARTING_CHAT_BLOCK,...WORKSPACE_BLOCKS,...HISTORICAL_WORKSPACE_BLOCKS,DESCRIBE_MEDIA_HOST_1_1,YOUTUBE_HOST_1_1,...GENERATION_HOST_RELEASES,...SDK_BUILTIN_BLOCKS.filter(block=>!WORKSPACE_BLOCKS.some(current=>current.manifest.id===block.manifest.id&&current.manifest.version===block.manifest.version)),...LEGACY_BLOCKS];
@@ -154,7 +156,7 @@ const SHARED_WORKSPACE_TYPES = currentBuiltinTypes('1.12.0','2.2.3',SCRIPT_WRITE
 const PRIOR_CURRENT_TYPES = currentBuiltinTypes('1.13.0','2.2.3',SCRIPT_WRITER_BLOCK.manifest.version,{'blueprint':'2.1.8','panel-strip':'2.3.6','board-editor':'2.2.9','animated-scene':'2.3.7','editor':'2.2.8'});
 const PREVIOUS_PORTABLE_TYPES=currentBuiltinTypes('1.14.0','2.2.4',SCRIPT_WRITER_BLOCK.manifest.version,{'blueprint':'2.1.8','panel-strip':'2.3.6','board-editor':'2.2.9','animated-scene':'2.3.7','editor':'2.2.8'});
 export const CURRENT_BUILTIN_TYPES = [...currentBuiltinTypes('1.15.0','2.2.4','2.1.4',{'voiceover':'2.1.4','shot-plan':'2.1.3','blueprint':'2.1.9','panel-strip':'2.3.7','board-editor':'2.2.10','animated-scene':'2.3.8','editor':'2.2.9'}),...REVENUE_REVIEW_PROJECT_TYPES,PRODUCT_AD_VARIANTS_PROJECT_TYPE,...FIRST_REVENUE_PROJECT_TYPES];
-const HISTORICAL_CURRENT_TYPES=[PRIOR_PRODUCT_AD_VARIANTS_PROJECT_TYPE,PREVIOUS_PRODUCT_AD_VARIANTS_PROJECT_TYPE,...PREVIOUS_PORTABLE_TYPES,...PRIOR_CURRENT_TYPES,...SHARED_WORKSPACE_TYPES,...SHARED_CANVAS_TYPES,...SHARED_BLUEPRINT_TYPES,...PRIOR_SHARED_TYPES,...MEDIA_LIBRARY_TYPES,...EDITOR_AUDIO_TYPES,...PLAYABLE_EDITOR_TYPES,...ADVANCED_PORTABLE_TYPES,...PORTABLE_MVP_TYPES,...PRE_PROMOTION_CURRENT_TYPES,...PREVIOUS_BUILTIN_TYPES.filter(type=>flows[type.legacyMode].includes('shot-plan')),...currentBuiltinTypes('1.1.0','1.1.0','1.1.0',PRIOR_HOST_WORKSPACE_VERSIONS)];
+const HISTORICAL_CURRENT_TYPES=[PRODUCT_AD_VARIANTS_PROJECT_TYPE_1_0_3,PRIOR_PRODUCT_AD_VARIANTS_PROJECT_TYPE,PREVIOUS_PRODUCT_AD_VARIANTS_PROJECT_TYPE,...PREVIOUS_PORTABLE_TYPES,...PRIOR_CURRENT_TYPES,...SHARED_WORKSPACE_TYPES,...SHARED_CANVAS_TYPES,...SHARED_BLUEPRINT_TYPES,...PRIOR_SHARED_TYPES,...MEDIA_LIBRARY_TYPES,...EDITOR_AUDIO_TYPES,...PLAYABLE_EDITOR_TYPES,...ADVANCED_PORTABLE_TYPES,...PORTABLE_MVP_TYPES,...PRE_PROMOTION_CURRENT_TYPES,...PREVIOUS_BUILTIN_TYPES.filter(type=>flows[type.legacyMode].includes('shot-plan')),...currentBuiltinTypes('1.1.0','1.1.0','1.1.0',PRIOR_HOST_WORKSPACE_VERSIONS)];
 export const BUILTIN_TYPES = [...CURRENT_BUILTIN_TYPES,...HISTORICAL_CURRENT_TYPES,...LEGACY_TYPES];
 export const workspaceBlock = (id,version)=>DISCOVERABLE_BLOCKS.find(block=>block.manifest.id===id && (!version || block.manifest.version===version));
 export const discoverableBuiltin = item=>!!workspaceBlock((item.manifest || item).id,(item.manifest || item).version);

package/packages/block-platform/chat-requirements.js

@@ -1,6 +1,10 @@
 import {auditProjectTypeConnections} from './project-type-composer.js';
 
-export function projectTypeRequirementsForChat(type,catalog=[],{currentStage,contextValues=[]}={}) {
+// `stepInputs` holds what each Step already has typed in ({stageId:{key:value}}):
+// an input a person supplies that is already there reads as provided, not as
+// still needing them.
+const supplied=value=>value!==undefined&&value!==null&&(typeof value!=='string'||value.trim()!=='')&&(!Array.isArray(value)||value.length>0);
+export function projectTypeRequirementsForChat(type,catalog=[],{currentStage,contextValues=[],stepInputs={}}={}) {
   if(!type)return undefined;
   const values=contextValues.map(value=>value.source?.kind==='block'?{...value,source:{...value.source,stageId:value.source.stepId || value.source.stageId}}:value);
   const audit=auditProjectTypeConnections(type,catalog,{contextValues:values}),enabled=audit.stages.filter(step=>!step.paused),steps=[];
@@ -13,8 +17,9 @@ export function projectTypeRequirementsForChat(type,catalog=[],{currentStage,con
   const issues=blocking.slice(0,10).map(issue=>({stageId:issue.stageId?String(issue.stageId).slice(0,160):null,message:String(issue.reason || issue.message).slice(0,240)}));
   let size=4500+JSON.stringify(issues).length,metadataSize=0,truncated=blocking.length>issues.length || blocking.some(issue=>String(issue.reason || issue.message).length>240 || String(issue.stageId || '').length>160);
   for(const step of relevant) {
-    const row={id:String(step.id).slice(0,160),label:String(step.label).slice(0,160),upcoming:currentIndex<0 || enabled.indexOf(step)>=currentIndex,requirements:step.requirements.slice(0,12).map(decision=>({key:String(decision.key || decision.requirement.key).slice(0,160),description:String(decision.requirement.description || '').slice(0,200),semantic:String(decision.requirement.semantic || '').slice(0,160),type:decision.requirement.type,required:decision.requirement.required,state:decision.state,reason:String(decision.reason || '').slice(0,240),source:summarizeSource(decision.selected),candidates:candidatesFor(decision).slice(0,3).map(summarizeSource)}))};
-    row.state=step.state;
+    const row={id:String(step.id).slice(0,160),label:String(step.label).slice(0,160),upcoming:currentIndex<0 || enabled.indexOf(step)>=currentIndex,requirements:step.requirements.slice(0,12).map(decision=>({key:String(decision.key || decision.requirement.key).slice(0,160),description:String(decision.requirement.description || '').slice(0,200),semantic:String(decision.requirement.semantic || '').slice(0,160),type:decision.requirement.type,required:decision.requirement.required,...(decision.state==='needs-user-input'&&supplied(stepInputs[step.id]?.[decision.key || decision.requirement.key])?{state:'provided',reason:'Set on this Step.'}:{state:decision.state,reason:String(decision.reason || '').slice(0,240)}),source:summarizeSource(decision.selected),candidates:candidatesFor(decision).slice(0,3).map(summarizeSource)}))};
+    // Once the inputs a person supplies are all there, the Step no longer waits on them.
+    row.state=step.state==='needs-user-input'&&!row.requirements.some(item=>item.state==='needs-user-input'&&item.required)?['chat','auto-connected'].find(state=>row.requirements.some(item=>item.state===state&&(item.required||state==='auto-connected')))||'ready':step.state;
     const issue=step.contractIssue?.message || step.connectionIssues?.[0]?.message;
     if(issue)row.issue=String(issue).slice(0,240);
     let length=JSON.stringify(row).length;

package/packages/block-platform/collaboration.js

@@ -61,7 +61,7 @@ export function mergeLiveDocument(local, remote, scope = 'editor') {
   return reconcileShared(local, result);
 }
 
-export function validateLiveDocument(document, scope = 'editor', {experimentalBrowser} = {}) {
+export function validateLiveDocument(document, scope = 'editor', {experimentalBrowser,experimentalNative} = {}) {
   safeDocument(document);
   assert(plain(document), 'DOCUMENT', 'Shared workspace must be an object');
   const collection = (items, name, maximum) => {
@@ -101,7 +101,7 @@ export function validateLiveDocument(document, scope = 'editor', {experimentalBr
       }
     }
     if (document.projectType !== undefined) {
-      const result=validateProjectType(document.projectType,BUILTIN_BLOCKS,{experimentalBrowser});
+      const result=validateProjectType(document.projectType,BUILTIN_BLOCKS,{experimentalBrowser,experimentalNative});
       assert(result.valid,'DOCUMENT',`Invalid shared Project Type: ${result.errors.map(error=>error.message).join(' ')}`);
     }
     collection(document.nodes,'nodes',5000); collection(document.edges,'edges',10000);
@@ -146,13 +146,13 @@ export function validateLiveDocument(document, scope = 'editor', {experimentalBr
 // validates already hydrated exact source only; no serializable document flag
 // opens admission, reads artifacts, verifies retained records or grants access.
 // Existing server save routes do not supply it and remain closed to this runtime.
-export async function validateCanvasWorkflowPair(document,{previous,complete=false,experimentalBrowser}={}) {
-  validateLiveDocument(document,'canvas',{experimentalBrowser});
+export async function validateCanvasWorkflowPair(document,{previous,complete=false,experimentalBrowser,experimentalNative}={}) {
+  validateLiveDocument(document,'canvas',{experimentalBrowser,experimentalNative});
   if(document.projectType === undefined) {assert(!complete,'DOCUMENT','A workflow handoff requires its Project Type');return document;}
   const type=document.projectType;
   for(const [index,old] of (previous?.projectType?.packages||[]).entries())
     assert(stableStringify(type.packages?.[index])===stableStringify(old),'VERSION','A saved package changed or moved. Keep existing package slots unchanged and append any newly reviewed release.');
-  const {canvas}=await compileTypeWorkspace(type,{experimentalBrowser}),expected=new Map(canvas.nodes.map(node=>[node.id,node])),actual=new Map(document.nodes.map(node=>[node.id,node]));
+  const {canvas}=await compileTypeWorkspace(type,{experimentalBrowser,experimentalNative}),expected=new Map(canvas.nodes.map(node=>[node.id,node])),actual=new Map(document.nodes.map(node=>[node.id,node]));
   for(const [id,node] of expected) {
     const current=actual.get(id);
     assert(current || !complete,'CONFLICT','The workflow is missing a required Block instance. Reload the project before applying it.');

package/packages/block-platform/first-revenue-project-types.js

@@ -1,5 +1,5 @@
 import mediaImport from '../../blocks/native/sm.import-media/versions/2.0.2/package.js';
-import photoReelComposer from '../../blocks/photo-reel-composer/versions/1.0.0/package.js';
+import photoReelComposer from '../../blocks/photo-reel-composer/versions/1.0.1/package.js';
 import editor from '../../blocks/native/sm.editor/versions/2.2.9/package.js';
 
 // Each Type carries its exact executable dependencies. The shared host supplies
@@ -8,7 +8,7 @@ import editor from '../../blocks/native/sm.editor/versions/2.2.9/package.js';
 // than collecting onboarding answers that the Block cannot consume.
 function photoReelType({id,name,description,brief,purpose,importLabel}) {
  return Object.freeze({
-  schemaVersion:1,id,version:'1.0.1',name,description,license:'MIT',startingChat:'native',
+  schemaVersion:1,id,version:'1.0.2',name,description,license:'MIT',startingChat:'native',
   summary:{text:description,origin:'human',generation:'authored',status:'ready'},
   defaults:{aspectRatio:'9:16',brief},
   onboarding:[],

package/packages/block-platform/flow-inspection.js

@@ -244,7 +244,7 @@ export function inspectProjectFlow(type,canvas={nodes:[],edges:[]},{projectId=nu
   const appliedActivity=last?.manualSelection?{applied:true,at:last.at||null,runId:null,...(selectedManually?{selection:selectedManually}:{})}:last?{applied:true,at:last.at||null,runId:last.executionRunId||last.semanticRunId||last.segmentRunId||last.runId||null,skipped:last.skipped===true&&!last.failureRecovery,execution:executionEvidence(last,{conditional:!!stage.condition,outputs:node?.data?.blockOutputs||{}})}:null;
   const condition=stage.condition?{inputKey:stage.condition.input,inputLabel:manifest?.inputs?.[stage.condition.input]?.description||stage.condition.input,path:stage.condition.path.slice(0,8),operator:stage.condition.operator,outcome:last?(last.skipped===true&&!last.failureRecovery?'skipped':'ran'):'unknown'}:null;
   const latestFailure=(node?.data?.blockFailedAttempts||[]).slice(-1)[0],failureIsLatest=typeof latestFailure?.runId==='string'&&Number.isFinite(Date.parse(latestFailure.at))&&(!last?.at||latestFailure.at>last.at)&&!failureRecovered(latestFailure),failedActivity=failureIsLatest?{runId:latestFailure.runId.slice(0,160),at:latestFailure.at,code:failureCode(latestFailure),durationMs:Number.isSafeInteger(latestFailure.diagnostic?.durationMs)?Math.max(0,Math.min(86400000,latestFailure.diagnostic.durationMs)):null,...Object.fromEntries(['attempt','batchIndex','batchCount'].filter(key=>failedCounter(latestFailure[key])).map(key=>[key,latestFailure[key]]))}:null;
-  return {id:row.id,nodeId:stageNodeId(stage),label:row.label,blockId:stage.blockId,version:stage.version,transformation:String(manifest?.description||'').slice(0,500),enabled:stage.enabled!==false,state:node?.data?.blockPrivacy?'restricted':active?'working':row.paused?'paused':node?.data?.blockStale||last&&last.digest!==node?.data?.blockDigest?'needs-updating':failureIsLatest?(failureCode(latestFailure)==='EXECUTION_FAILED'?'failed':'needs-recovery'):last?.skipped===true&&!last?.failureRecovery&&stage.condition?'skipped':last?'finished':row.state==='broken'||row.state==='needs-user-input'?'needs-choice':'waiting',...(condition?{condition}:{}),inputs:inputs.map(input=>({...input,valueType:manifest?.inputs?.[input.key]?.type||row.requirements.find(requirement=>requirement.key===input.key)?.requirement?.type||null})),outputs,unusedResults,unusedResultsRevision,unusedResultsCount,unusedResultsOffset,unusedResultsLimit,unusedResultsNextOffset,...(retainedPage?.candidateId?{inspectedRetainedResult}:{}),usedInputs,activity:active?{...(appliedActivity||{}),active,activeRuns,activeRunsOmitted:Math.max(0,(runsByPlacement.get(row.id)||[]).length-activeRuns.length)}:failedActivity?{...(appliedActivity||{}),failedAttempt:failedActivity}:appliedActivity,history:recentHistory,historyComplete,retainedLoopRuns:retainedWorkflowLoopSummaries(canvas,row.id)};
+  return {id:row.id,nodeId:stageNodeId(stage),label:row.label,blockId:stage.blockId,version:stage.version,...(manifest?.permissions?.capabilities?.includes('connection.execute')?{connector:true}:{}),transformation:String(manifest?.description||'').slice(0,500),enabled:stage.enabled!==false,state:node?.data?.blockPrivacy?'restricted':active?'working':row.paused?'paused':node?.data?.blockStale||last&&last.digest!==node?.data?.blockDigest?'needs-updating':failureIsLatest?(failureCode(latestFailure)==='EXECUTION_FAILED'?'failed':'needs-recovery'):last?.skipped===true&&!last?.failureRecovery&&stage.condition?'skipped':last?'finished':row.state==='broken'||row.state==='needs-user-input'?'needs-choice':'waiting',...(condition?{condition}:{}),inputs:inputs.map(input=>({...input,valueType:manifest?.inputs?.[input.key]?.type||row.requirements.find(requirement=>requirement.key===input.key)?.requirement?.type||null})),outputs,unusedResults,unusedResultsRevision,unusedResultsCount,unusedResultsOffset,unusedResultsLimit,unusedResultsNextOffset,...(retainedPage?.candidateId?{inspectedRetainedResult}:{}),usedInputs,activity:active?{...(appliedActivity||{}),active,activeRuns,activeRunsOmitted:Math.max(0,(runsByPlacement.get(row.id)||[]).length-activeRuns.length)}:failedActivity?{...(appliedActivity||{}),failedAttempt:failedActivity}:appliedActivity,history:recentHistory,historyComplete,retainedLoopRuns:retainedWorkflowLoopSummaries(canvas,row.id)};
  });
  if(retainedResultPage){const placement=placements.find(item=>item.id===retainedResultPage.placementId);if(!placement||placement.unusedResultsRevision!==retainedResultPage.revision||retainedResultPage.operation==='list'&&retainedResultPage.offset>placement.unusedResultsCount||retainedResultPage.candidateId&&!placement.inspectedRetainedResult)throw new Error('This retained result list or exact candidate changed. Inspect Result again.');}
  if(receiptInputPage){const entry=placements.find(item=>item.id===receiptInputPage.placementId)?.history?.find(item=>projectFlowRunReceiptIdentity(item)===receiptInputPage.receiptId);if(!entry||entry.inputsRevision!==receiptInputPage.revision||!entry.inputs||receiptInputPage.offset>entry.inputsCount)throw new Error('This retained receipt or its captured inputs changed. Inspect the run again.');}
@@ -271,7 +271,7 @@ export function inspectProjectFlow(type,canvas={nodes:[],edges:[]},{projectId=nu
   if(placement.condition)conditionalLabels.push(`Conditional Block · last recorded ${placement.condition.outcome==='unknown'?'not run':placement.condition.outcome}`);
   return {from:input.sourcePlacementId,outputKey:input.sourceOutputKey,to:placement.id,inputKey:input.key,state:input.state,materialized:input.materialized===true,sourceRunId:input.pinRunId||sourceOutput?.runId||null,adapter:input.adapter,...(conditionalLabels.length?{conditionalLabel:conditionalLabels.join(' · ')}:{})};
  }));
- return projectFlowSnapshot({contractVersion:PROJECT_FLOW_CONTRACT_VERSION,projectId,definition:{id:type.id,version:type.version},acceptanceCriteria:(type.acceptanceCriteria||[]).map(item=>({...item,verified:false})),goalSourceMaterials:validateGoalSourceMaterials(type),goalSourceInputs:currentGoalSourceInputs(type,[...BUILTIN_BLOCKS,...catalog]),placements,edges,issues:audit.issues.slice(0,50).map(issue=>({placementId:issue.stageId||null,inputKey:issue.key||null,message:issue.message||issue.reason||'Connection needs attention'})),partial:audit.requirementsInspected===false});
+ return projectFlowSnapshot({contractVersion:PROJECT_FLOW_CONTRACT_VERSION,projectId,definition:{id:type.id,version:type.version},...(type.groups?.length?{jobs:type.groups.map(group=>({id:group.id,label:group.label,parts:[...group.stages]}))}:{}),acceptanceCriteria:(type.acceptanceCriteria||[]).map(item=>({...item,verified:false})),goalSourceMaterials:validateGoalSourceMaterials(type),goalSourceInputs:currentGoalSourceInputs(type,[...BUILTIN_BLOCKS,...catalog]),placements,edges,issues:audit.issues.filter(issue=>!(issue.state==='needs-user-input'&&placements.find(placement=>placement.id===issue.stageId)?.inputs?.some(input=>input.key===issue.key&&input.state==='ready'))).slice(0,50).map(issue=>({placementId:issue.stageId||null,inputKey:issue.key||null,...(issue.state?{state:issue.state}:{}),message:issue.message||issue.reason||'Connection needs attention'})),partial:audit.requirementsInspected===false});
 }
 
 // A read-only explanation of the current handoff. Each hop is an inspected

package/packages/block-platform/native-application-validation-context.js

@@ -0,0 +1,20 @@
+import {assert,plain,safeDocument,stableStringify} from '../block-sdk/contracts.js';
+import {defineNativeApplicationPackage} from '../block-sdk/native-application-package.js';
+
+// Source structure only. This opaque capability grants no execution, source
+// access, installation, result authentication, state commit or runtime setup.
+const contexts=new WeakMap();
+export const isNativeApplicationPackage=value=>value?.manifest?.runtime==='native-application'&&Object.hasOwn(value,'nativeApplication');
+export function createNativeApplicationValidationContext(options){
+ assert(plain(options)&&Reflect.ownKeys(options).length===1&&Object.hasOwn(options,'sources')&&Object.hasOwn(Object.getOwnPropertyDescriptor(options,'sources'),'value'),'NATIVE_APPLICATION_CONTEXT','Supply only exact native sources for structure validation.');
+ safeDocument(options.sources);
+ assert(Array.isArray(options.sources)&&options.sources.length>0&&options.sources.length<=100,'NATIVE_APPLICATION_CONTEXT','Prevalidate 1–100 exact native application sources.');
+ const entries=new Map();
+ for(const value of options.sources){const source=defineNativeApplicationPackage(value),key=stableStringify(source);assert(!entries.has(key),'NATIVE_APPLICATION_CONTEXT','Duplicate exact native source.');entries.set(key,source);}
+ const context=Object.freeze(Object.create(null));contexts.set(context,entries);return context;
+}
+export function nativeApplicationValidationSource(context,value){
+ const entries=contexts.get(context);
+ assert(entries,'NATIVE_APPLICATION_RUNTIME_UNAVAILABLE','Native source structure requires an opaque trusted validation context; package JSON cannot grant access or admission.');
+ const source=entries.get(stableStringify(value));assert(source,'NATIVE_APPLICATION_PIN','Native source differs from this host-prevalidated package.');return source;
+}

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

@@ -0,0 +1,67 @@
+// What people (and Chat, which speaks to them) read about a StillMade Block.
+// Published manifests keep their exact technical descriptions; releases are
+// immutable, so the plain wording for first-party Blocks lives here, by Block id.
+// A Block whose own description is already plain needs no entry.
+export const PLAIN_BLOCK_DESCRIPTIONS=Object.freeze({
+ 'sm.script':'Write and edit a script with AI. Set a length, add notes, and go back to earlier versions.',
+ 'sm.shot-plan':'Turn a script into a list of timed shots, then edit what each shot shows and how long it lasts.',
+ 'sm.blueprint':'Plan your video’s scenes, characters and look in one place, and lock the parts you want to keep.',
+ 'sm.pipeline':'Lay out your project on a canvas and connect its pieces, keeping your Steps and content.',
+ 'sm.video-assets':'Choose which images and clips go into your video, in order, from everything the project has made or imported.',
+ 'sm.editor':'The full video editor: text and titles, captions, transitions, music, effects and export are built in.',
+ 'sm.panel-strip':'Turn a script into pictures timed to the voice, then edit scenes, images and transitions.',
+ 'sm.board-editor':'Make text and pictures move on a whiteboard in time with a voice, then send it to the Editor.',
+ 'sm.animated-scene':'Build animated scenes from your images and characters, preview them, then send them to the Editor.',
+ 'stillmade.product-ad-variants':'Make three short product ads with different opening hooks from your own footage. Nothing is invented.',
+ 'sm.youtube':'Upload a finished video to your connected YouTube channel.',
+ 'sm.stock-search':'Search free-to-use stock photos and videos and pick one.',
+ 'sm.export-video':'Turn your timeline into a video file you can download and keep in the project.',
+ 'sm.export-audio':'Turn your timeline into an audio file you can download and keep in the project.',
+ 'sm.motion-graphics':'Add animated titles, text, charts and transitions to your timeline. You see the change before it applies.',
+ 'sm.score':'Put music, sound effects and voiceover from your project on the timeline. You see the change before it applies.',
+ 'stillmade.short-form-finish':'Turn your clips and subtitles into a captioned short video you can still edit.',
+ 'stillmade.occasion-story':'Arrange photos and video messages into a birthday, anniversary or farewell video you can still edit.',
+ 'stillmade.release-visuals':'Make a social teaser or lyric clip for a song from its cover art and recording.',
+ 'stillmade.photo-reel-composer':'Arrange property or product photos and your text into a 20–30 second reel. No AI images.',
+ 'sm.import-media':'Upload or choose your own photos, images, video and audio, and put them in order for the next Step.',
+ 'sm.chat':'Work out a script by chatting with AI.',
+ 'sm.rough-cut':'Put your chosen clips together into a first cut you can review.',
+ 'sm.final-edit':'Have AI suggest a final polish for a finished timeline. You review the changes before they apply.',
+ 'sm.edit-assistant':'Ask for a timeline change in your own words, such as trimming a section. You review it before it applies.',
+ '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.quality-audit':'Check your images and clips for quality problems before you export.',
+ 'sm.compare':'Compare two images with a slider and keep the one you prefer.',
+ '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.',
+ 'sm.thumbnail':'Make a square thumbnail image from a short description.',
+ 'sm.write-summary':'Turn data or notes, such as an app’s results, into a short summary in plain words.',
+ 'sm.generate-video':'Make a short video clip from a description.',
+ 'sm.character':'Describe a character once so your images and videos keep them the same.',
+ 'sm.location':'Describe a place once so your images and videos keep it the same.',
+ 'sm.style':'Set a look, with colors, lighting and camera style, for your images to follow.',
+ 'sm.research':'Collect your notes and a source link into research you can reuse. It does not browse the web.',
+ 'sm.image-editor':'Adjust an image’s brightness and contrast.',
+ 'sm.describe-media':'Have AI describe what is in an image.',
+ 'sm.transcribe':'Turn speech in an audio file into text, with a time for each word.',
+ 'sm.shot-plan-assistant':'Have AI suggest a shot list from your script, keeping the shots you already have.',
+ 'sm.animated-scene-assistant':'Have AI suggest how an animated scene is laid out and how it moves.',
+ 'sm.blueprint-assistant':'Have AI suggest edits to your video plan.',
+ 'sm.whiteboard-assistant':'Have AI build whiteboard boards, timing and motion from what you ask for.',
+});
+
+// Words that describe how StillMade works inside rather than what a person gets.
+export const INTERNAL_WORDS=/\b(exact|bounded|portable|capabilit(y|ies)|fulfillment|source-bound|canonical|typed|stored|production prompt|approved|retained|semantic|workspace|handoff|sandbox|dossier)\b/i;
+
+/** The description to show for a Block: a first-party Block's plain wording, else its own. */
+// An app task's own description is written for developers (field rules, other
+// task ids); people see its first sentence only.
+export function firstSentence(text,max=200){
+ const plain=String(text||'').replace(/\s+/g,' ').trim(),end=plain.search(/[.!?](\s|$)/);
+ const sentence=end>=0?plain.slice(0,end+1):plain;
+ return sentence.length>max?`${sentence.slice(0,max-1).trimEnd()}…`:sentence;
+}
+export function plainBlockDescription(manifest){
+ if(PLAIN_BLOCK_DESCRIPTIONS[manifest?.id])return PLAIN_BLOCK_DESCRIPTIONS[manifest.id];
+ return /^connected\./.test(String(manifest?.id||''))?firstSentence(manifest?.description):manifest?.description||'';
+}

package/packages/block-platform/product-ad-variants-project-type.js

@@ -1,11 +1,12 @@
-import shortForm from '../../blocks/short-form-finish/versions/1.0.1/package.js';
+import shortFormV101 from '../../blocks/short-form-finish/versions/1.0.1/package.js';
+import shortFormV103 from '../../blocks/short-form-finish/versions/1.0.3/package.js';
 import variants from '../../blocks/product-ad-variants/versions/1.0.0/package.js';
 import editorV229 from '../../blocks/native/sm.editor/versions/2.2.9/package.js';
 import editorV2210 from '../../blocks/native/sm.editor/versions/2.2.10/package.js';
 import editorV2211 from '../../blocks/native/sm.editor/versions/2.2.11/package.js';
 
 const description='Make three distinct approved hook and real-footage opening variants from one supplied product demonstration, with a separate editable export for each.';
-const productAdVariantsType=(version,editor)=>Object.freeze({
+const productAdVariantsType=(version,editor,shortForm=shortFormV101)=>Object.freeze({
  schemaVersion:1,id:'stillmade.product-ad-variants-workflow',version,name:'Product Footage Ad Variants',description,license:'MIT',startingChat:'native',
  summary:{text:description,origin:'human',generation:'authored',status:'ready'},
  defaults:{aspectRatio:'9:16',brief:'Upload one authorized real product demonstration. Prepare a complete 5–60 second portrait edit with full framing and exact approved copy. Optional captions must be reviewed against the original speech. Choose three different non-overlapping 1–3 second source moments and supply three distinct approved hooks. Each candidate labels that source preview, then retains the same complete demonstration. Review and export A, B and C separately. No generated UGC, invented claims, automatic winning-hook selection or ad launch is included.'},
@@ -23,5 +24,7 @@ const productAdVariantsType=(version,editor)=>Object.freeze({
 });
 export const PREVIOUS_PRODUCT_AD_VARIANTS_PROJECT_TYPE=productAdVariantsType('1.0.1',editorV229);
 export const PRIOR_PRODUCT_AD_VARIANTS_PROJECT_TYPE=productAdVariantsType('1.0.2',editorV2210);
-export const PRODUCT_AD_VARIANTS_PROJECT_TYPE=productAdVariantsType('1.0.3',editorV2211);
+export const PRODUCT_AD_VARIANTS_PROJECT_TYPE_1_0_3=productAdVariantsType('1.0.3',editorV2211);
+// 1.0.4: rights are confirmed once in the Content & IP Policy at sign-up, not per project.
+export const PRODUCT_AD_VARIANTS_PROJECT_TYPE=productAdVariantsType('1.0.4',editorV2211,shortFormV103);
 export default PRODUCT_AD_VARIANTS_PROJECT_TYPE;

package/packages/block-platform/project-context.js

@@ -121,7 +121,7 @@ export function projectContextSnapshot(data={},options={}) {
   // generic native-media loop too. Excluding Block results must exclude the
   // whole programmable node, including its legacy versions and input claims.
   if(options.includeBlockOutputs===false&&node.type==='programmableBlockNode')continue;
-  const d=object(node.data),label=d.title || d.name || d.label || node.id;
+  const d=object(node.data),label=d.title || d.name || d.label || d.blockPackage?.manifest?.name || node.id;
   if(node.type==='programmableBlockNode')for(const value of [...Object.values(object(d.blockInputs)),...(d.blockStale?[]:Object.values(object(d.blockOutputs)))])addFiles(value,d,label);
   const referenceField={characterReferenceNode:'characters',locationReferenceNode:'locations',styleNode:'styles'}[node.type];
   const role=referenceField ? {characters:'character_reference',locations:'location_reference',styles:'style_reference'}[referenceField] : undefined;
@@ -176,7 +176,7 @@ export function projectContextSnapshot(data={},options={}) {
    for(const [name,declared] of Object.entries(d.blockPackage?.manifest?.outputs || {})){
     if(!['image','video','audio','asset','image[]','video[]','audio[]','asset[]'].includes(declared.type))continue;
     const output=result.outputs?.[name];
-    for(const ref of Array.isArray(output) ? output : output ? [output] : [])addMedia({...ref,source:'block',owner,role:declared.role,label:entry.step?.label || node.id,record:{createdAt:result.at || entry.at},active:false});
+    for(const ref of Array.isArray(output) ? output : output ? [output] : [])addMedia({...ref,source:'block',owner,role:declared.role,label:entry.step?.label || d.blockPackage?.manifest?.name || node.id,record:{createdAt:result.at || entry.at},active:false});
    }
   }
  }
@@ -275,7 +275,7 @@ export function projectContextSnapshot(data={},options={}) {
     for(const [name,declared] of Object.entries(d.blockPackage?.manifest?.outputs || {})){
      if(!['image','video','audio','asset','image[]','video[]','audio[]','asset[]'].includes(declared.type))continue;
      const output=row.outputs?.[name];
-     for(const ref of Array.isArray(output)?output:output?[output]:[])addMedia({...ref,source:'block',owner,role:declared.role,label:d.title || d.label || node.id,record:{createdAt:row.at},active,generated:active});
+     for(const ref of Array.isArray(output)?output:output?[output]:[])addMedia({...ref,source:'block',owner,role:declared.role,label:d.title || d.label || d.blockPackage?.manifest?.name || node.id,record:{createdAt:row.at},active,generated:active});
     }
    }
    for(const row of [...list(d.blockBatchResults),...list(d.blockUnusedResults),...list(d.blockPinnedResults).map(result=>({...result,active:false}))]){
@@ -283,7 +283,7 @@ export function projectContextSnapshot(data={},options={}) {
     for(const [name,declared] of Object.entries(d.blockPackage?.manifest?.outputs||{})){
      if(!['image','video','audio','asset','image[]','video[]','audio[]','asset[]'].includes(declared.type))continue;
      const output=row.outputs?.[name];
-     for(const ref of Array.isArray(output)?output:output?[output]:[])addMedia({...ref,source:'block',owner,role:declared.role,label:d.title||d.label||node.id,record:{createdAt:row.at},active:false});
+     for(const ref of Array.isArray(output)?output:output?[output]:[])addMedia({...ref,source:'block',owner,role:declared.role,label:d.title||d.label||d.blockPackage?.manifest?.name||node.id,record:{createdAt:row.at},active:false});
     }
    }
   }