stillmade-sdk 0.1.4 → 0.1.6

package/SDK.md

@@ -144,7 +144,7 @@ For an original implementation, retain complete license notices and at least two
 ```sh
 node packages/block-cli/cli.js pack ./my-block ./my-block.stillmade-block --original
 ```
-Select that file with **Choose package** for the same source and interface. Packaging adds retained source evidence and reruns applicable checks; it does not rewrite the implementation. Output files are never silently overwritten. Use repository evidence instead of `--original` when reusing third-party code.
+Choose the folder that holds that file with **Import folder** for the same source and interface. Packaging adds retained source evidence and reruns applicable checks; it does not rewrite the implementation. Output files are never silently overwritten. Use repository evidence instead of `--original` when reusing third-party code.
 
 ### Photo-editor folder example
 The extracted SDK contains `examples/original-photo-editor/`, including its actual custom interface, pixel processing and fixtures. Select that folder directly or try [its packaged original](/block-sdk/examples/original-photo-editor.stillmade-block). This bounded example adjusts brightness/color and rotates pixels with transparency. See [the supported original-authoring contract](/docs/build/original-blocks).
@@ -152,9 +152,33 @@ The extracted SDK contains `examples/original-photo-editor/`, including its actu
 ### Use and iterate
 Add the Block to a Project Type, configure its inputs, and run it. Keep source changes in checkpoints; publish a new release version when the behavior changes. See [versioning and remixing](/docs/distribute/versioning).
 
+## Build a Block with your AI
+
+### For you
+Give your coding agent (Claude Code, Cursor, Codex, Gemini CLI or similar) a link to this page and say what the Block should do, for example: “Build a StillMade Block that turns a script into a shot list. Follow https://stillmade.shop/docs/build/with-your-ai.md”. It sets up the SDK, builds the Block and checks it on its own; you only answer questions about what the Block should do. A chat assistant without a terminal cannot download or run anything, so use a coding agent, or connect StillMade's [MCP server](/docs/native-mcp.md). Either way, StillMade refuses to install a Block that fails its readiness check.
+
+### For the coding agent
+Do every step yourself. Do not ask the person to download, unzip, open a folder or run a command; only ask about what the Block should do.
+
+1. **Get the SDK.** It is `/block-sdk/stillmade-sdk-0.1.0.zip` on the same site as this page: replace this page's path with that one (for example `https://stillmade.shop/block-sdk/stillmade-sdk-0.1.0.zip`, or `http://localhost:3000/block-sdk/stillmade-sdk-0.1.0.zip` when this page came from localhost). If `stillmade-blocks/AGENTS.md` already exists in your working folder, reuse that folder. Otherwise download and extract it into `stillmade-blocks`:
+```sh
+curl -fsSL "<SDK URL>" -o stillmade-sdk.zip && unzip -q stillmade-sdk.zip -d stillmade-blocks && rm stillmade-sdk.zip
+```
+On Windows PowerShell:
+```powershell
+Invoke-WebRequest "<SDK URL>" -OutFile stillmade-sdk.zip; Expand-Archive stillmade-sdk.zip stillmade-blocks; Remove-Item stillmade-sdk.zip
+```
+The SDK needs Node.js 22 or later and nothing else; its runtime is bundled, so never run `npm install` in it.
+2. **Read `stillmade-blocks/AGENTS.md` in full** before writing code. It is the contract StillMade checks every Block against.
+3. **Build inside `stillmade-blocks`.** Scaffold with `node packages/block-cli/cli.js create <name> javascript` (or `image`, `stateful`, `capability`), then iterate with `node packages/block-cli/cli.js validate <name>` and `test <name>`.
+4. **Run the readiness gate before you call anything ready:** `node packages/block-cli/cli.js gate .` from `stillmade-blocks`. Report the exact status it prints. If it fails, fix the listed checks and run it again. If you cannot fix them, tell the person plainly that the Block is not ready and list the failing checks. A browser application reports NEEDS STILLMADE REVIEW: tell the person to import it so StillMade can run its isolated review.
+5. **Hand it over.** Give the person the full path of the `<name>` folder. In StillMade they choose **Import folder** and select that folder.
+
+`stillmade-blocks` contains hooks that run the gate automatically when a Claude Code or Cursor session started in that folder finishes a turn. In the session that downloaded the SDK those hooks are not active yet, so run the gate yourself as in step 4.
+
 ## Block builder contract
 
-Contract `stillmade.block-builder@1.0.0`. Humans, coding agents, imported source, GitHub repositories and generated code all adapt to the Block platform; anything that becomes a StillMade Block obeys this contract.
+Contract `stillmade.block-builder@1.3.0`. Humans, coding agents, imported source, GitHub repositories and generated code all adapt to the Block platform; anything that becomes a StillMade Block obeys this contract.
 
 ### Source of truth
 
@@ -164,13 +188,27 @@ Treat the current SDK (`stillmade.block.json` manifest, `packages/block-sdk` con
 
 Before building, check what already exists (`find_existing_blocks` over MCP, or the Marketplace and your library) by the inputs, results and operations the goal needs. Use an installed or reviewed Block that already does it; remix a close one so its license, notices and creator credit stay attached; chain existing Blocks and build only the missing step. Never republish another creator's source without remix lineage: public copies are refused. Build a new Block when nothing fits or the person asks for their own version, and say which similar Blocks you considered.
 
+### One job per Step
+
+A Step is one job: the work between two moments where a person or the outside world must see the result. Start a new Step only at one of three points; everything else is a part of the neighboring Step.
+
+1. **A person works with the result**: reads, edits, picks or approves it (a workspace Block such as a script, a Canvas or an Editor, or an approval). That is why Chat, Bible, Canvas and Editor are four Steps.
+2. **Finding new things turns into handling each one**: the trigger (a schedule or an app event), the app read, its filter and "only new" are the first job; what is done with each item is the next job. A trigger is a setting of the first job, never a Step of its own.
+3. **The result leaves StillMade**: it is sent, posted, published, paid or written into another app. Consecutive writes to the same app, with the glue that shapes data for them, are one job.
+
+A part that only runs in the desktop app cannot share a Step with cloud parts. Before adding a Step, name which of the three reasons makes it separate; if none applies, make it a part of a neighbor. A Step nobody would ever open must not exist on its own. Prefer an app task's own filter (a Gmail query such as `has:attachment filename:png`) to an AI check, and use AI decide only for judgement.
+
+Inside one job, each capability stays its own part: a capability Block performs exactly one hosted operation and a connector one app task, so every part keeps its own permission, approval and credit rules, and StillMade groups the parts of one job into one Step (`groups` in the Project Type). Never invent a combined runtime. When one Block can do the whole job with documented primitives (a JavaScript Block doing several local transforms, a workspace owning its whole document), build it as one Block.
+
+Examples: "every new email with an image becomes a generated image" is two Steps, "Gmail · New emails with images" (When, fetch with an image filter, only new) and "Image from email" (AI write, Generate image); listing When, Fetch, Only new, AI decide, Continue only if, AI write and Generate image as seven Steps splits one job into its parts. "A new Meta lead goes to HubSpot" is three Steps: "Meta Ads · New leads", "Qualify lead" and "HubSpot · Add contact".
+
 ### Define the capability first
 
-Translate the request into an explicit capability contract before implementation: what the Block does; each input with its type, meaning and whether it is required (prefer optional settings with safe defaults over extra required questions); each output with its type and meaning; persistent state; project context it reads; permissions; UI; long-running behavior; expected failures; cancellation; determinism; and whether it needs hosted models, media, desktop tools or shared editing. Keep the public interface as small and general as possible and keep implementation details out of it.
+Translate the request into an explicit capability contract before implementation: what the Block does; each input with its type, meaning and whether it is required (prefer optional settings with safe defaults over extra required questions); each output with its type and meaning; persistent state; project context it reads; permissions; UI; long-running behavior; expected failures; cancellation; determinism; and whether it needs hosted models, media, desktop tools or shared editing. Keep the public interface as small and general as possible (few required inputs, one primary output) and keep implementation details out of it; small means a small interface, never a fragment of a job. A Block that generates images, video or speech declares only its prompt and output: every Step that runs it gets the host’s generation settings (model, quality, length and resolution, voice, speed, how many), saved with the Step, changed on its page or by Chat, and shown with their cost before each run.
 
 ### Blocks compose
 
-A Block is not a mini-app. Its outputs become other Blocks' inputs and its inputs come from other Blocks, project context or the user. Use the typed port system: shared StillMade types (`image`, `video`, `audio`, `asset`, `script`, `shot[]`, ...), a `semantic` meaning on every port, `required` and a short `description`. Mark exactly one primary input and one primary output so Project Type Steps connect automatically, and use `kind: "task"`: a `workspace` Block owns a project document and is never connected automatically. Inputs marked `context` read the project and cannot receive a connection from another Step. Output reusable StillMade values: media references (`{kind,assetId,versionId,url}`) and structured production values with `schemaVersion: 1`, preserving provenance, versions and relationships downstream Blocks need. Never make ordinary users wire JSON, copy IDs, understand internal paths or translate one Block's output into another: `createUniversalResolver()` (the same engine as the Project Type composer) resolves inputs from compatible upstream outputs, permitted project context and, for optional non-context inputs, `StillMade.requestFromUser`.
+A Block is one job: not a mini-app of many jobs and not a fragment of one. Its outputs become other Blocks' inputs and its inputs come from other Blocks, project context or the user. Use the typed port system: shared StillMade types (`image`, `video`, `audio`, `asset`, `script`, `shot[]`, ...), a `semantic` meaning on every port, `required` and a short `description`. Mark exactly one primary input and one primary output so Project Type Steps connect automatically, and use `kind: "task"`: a `workspace` Block owns a project document and is never connected automatically. Inputs marked `context` read the project and cannot receive a connection from another Step. Output reusable StillMade values: media references (`{kind,assetId,versionId,url}`) and structured production values with `schemaVersion: 1`, preserving provenance, versions and relationships downstream Blocks need. Never make ordinary users wire JSON, copy IDs, understand internal paths or translate one Block's output into another: `createUniversalResolver()` (the same engine as the Project Type composer) resolves inputs from compatible upstream outputs, permitted project context and, for optional non-context inputs, `StillMade.requestFromUser`.
 
 ### Use platform primitives
 
@@ -180,9 +218,13 @@ Prefer, in order: an SDK capability; a documented host capability (the hosted op
 
 Never make a Block look functional through hard-coded local paths, developer-machine dependencies, undocumented environment variables, admin or database access, hidden core modifications, direct database writes, fake or mocked production results, hand-prepared test assets that hide incompatibilities, credentials in code, or assumptions about one user's machine. The finished Block must work through the same interfaces available to any installed Block; `permissions.network`, `permissions.filesystem` and `permissions.secrets` must be empty arrays.
 
+### Name it briefly
+
+Give the Block a short, plain name of 40 characters or fewer that says what it does ("Captioned Clip", not "Captioned Business Clip Generator With Review"). The name appears in step bars, Project Type cards and pickers, so put the detail in the description instead. New releases with a longer name do not pass readiness.
+
 ### Interface
 
-If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction genuinely needs one. Expose the capability, not the implementation: meaningful controls, sensible defaults, preview, direct manipulation, progress, clear errors and visible outputs. Do not show raw JSON, internal IDs, filesystem details, provider terminology or developer settings unless the Block is itself a developer tool. Follow the host appearance (Light, Dark and White) and the mobile layout contract: one interface for every screen size that fits a 320 CSS-pixel phone without horizontal scrolling.
+If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction genuinely needs one. Expose the capability, not the implementation: meaningful controls, sensible defaults, preview, direct manipulation, progress, clear errors and visible outputs. Do not show raw JSON, internal IDs, filesystem details, provider terminology or developer settings unless the Block is itself a developer tool. When a person chooses among options they need to hear or see (voices, music, sounds, fonts, looks, colors, templates or images), let them preview each option before choosing: a sample to play or a thumbnail, from the Block's own files or the host's free samples, never a paid generation. Leave previews out only when the builder states there is nothing to preview. Choices StillMade owns, such as voices and models in the run review, already show their samples. Follow the host appearance (Light, Dark and White) and the mobile layout contract: one interface for every screen size that fits a 320 CSS-pixel phone without horizontal scrolling.
 
 ### Shared editing
 
@@ -218,11 +260,11 @@ StillMade runs the readiness check on every Block it admits: manifest and contra
 
 ### Project Types
 
-A Project Type is an ordered production workflow. Each Step's primary output must be a compatible input for the next Step, secondary values come from permitted project context, and every member Block obeys this contract. Install Blocks into a realistic Project Type: project chat must understand each Step, inputs must resolve intuitively, outputs and execution state must be visible, failures must be diagnosable, and the user must be able to continue through the workflow.
+A Project Type is an ordered production workflow. Each Step's primary output must be a compatible input for the next Step, secondary values come from permitted project context, and every member Block obeys this contract. Install Blocks into a realistic Project Type: project chat must understand each Step, inputs must resolve intuitively, outputs and execution state must be visible, failures must be diagnosable, and the user must be able to continue through the workflow. Group the parts of one job into one Step instead of listing helper parts as Steps; most automations are two to four Steps.
 
 ### Readiness report
 
-Finish with a Block Readiness Report: capability, contract (inputs, outputs, permissions, dependencies), platform APIs used, tests actually performed and their results, the composition test (upstream, Block, downstream), known limitations, unsupported requirements and any platform gap with its smallest general primitive. Choose exactly one status: PRODUCTION READY (every applicable check passed), READY WITH DOCUMENTED LIMITATIONS (works reliably within stated boundaries), BLOCKED BY PLATFORM CAPABILITY (needs a missing generic primitive) or FAILED. Never label a Block production ready to satisfy a request, and never claim a check ran when it did not.
+Finish with a Block Readiness Report: capability, contract (inputs, outputs, permissions, dependencies), platform APIs used, tests actually performed and their results, the composition test (upstream, Block, downstream), known limitations, unsupported requirements and any platform gap with its smallest general primitive. Report exactly one status, the one StillMade's readiness check returned (`ready` in the SDK CLI, `check_block_readiness` over MCP), never one you chose: PRODUCTION READY (every applicable check passed), READY WITH DOCUMENTED LIMITATIONS (works reliably within stated boundaries), BLOCKED BY PLATFORM CAPABILITY (needs a missing generic primitive) or FAILED. Never label a Block production ready to satisfy a request, and never claim a check ran when it did not.
 
 ### Definition of done
 
@@ -271,6 +313,19 @@ An instance of a Block inside a Project Type. Each Step has its own instance ID,
 ### Project Type
 An ordered production workflow. Its persisted `stages` array stores Steps for compatibility with existing projects. Users can add, remove, duplicate, configure, disable, or reorder Steps. The protected starting chat belongs to the host and cannot be replaced or remixed.
 
+### One job per Step
+A Step is one job: the work between two moments where a person or the outside world must see the result. Start a new Step only at one of three points; everything else is a part of the neighboring Step.
+
+1. **A person works with the result**: reads, edits, picks or approves it (a workspace Block such as a script, a Canvas or an Editor, or an approval). That is why Chat, Bible, Canvas and Editor are four Steps.
+2. **Finding new things turns into handling each one**: the trigger (a schedule or an app event), the app read, its filter and "only new" are the first job; what is done with each item is the next job. A trigger is a setting of the first job, never a Step of its own.
+3. **The result leaves StillMade**: it is sent, posted, published, paid or written into another app. Consecutive writes to the same app, with the glue that shapes data for them, are one job.
+
+A part that only runs in the desktop app cannot share a Step with cloud parts. Before adding a Step, name which of the three reasons makes it separate; if none applies, make it a part of a neighbor. A Step nobody would ever open must not exist on its own. Prefer an app task's own filter (a Gmail query such as `has:attachment filename:png`) to an AI check, and use AI decide only for judgement.
+
+Inside one job, each capability stays its own part: a capability Block performs exactly one hosted operation and a connector one app task, so every part keeps its own permission, approval and credit rules, and StillMade groups the parts of one job into one Step (`groups` in the Project Type). Never invent a combined runtime. When one Block can do the whole job with documented primitives (a JavaScript Block doing several local transforms, a workspace owning its whole document), build it as one Block.
+
+Examples: "every new email with an image becomes a generated image" is two Steps, "Gmail · New emails with images" (When, fetch with an image filter, only new) and "Image from email" (AI write, Generate image); listing When, Fetch, Only new, AI decide, Continue only if, AI write and Generate image as seven Steps splits one job into its parts. "A new Meta lead goes to HubSpot" is three Steps: "Meta Ads · New leads", "Qualify lead" and "HubSpot · Add contact".
+
 ### Typed connections
 An image-producing Block can connect to an image-consuming Block. Primary ports make insertion predictable; semantic roles distinguish a source image from a character reference. Secondary inputs can bind to project context.
 
@@ -1001,7 +1056,20 @@ Its capability declaration is:
 ```
 
 Declare exactly one prompt input (`text`, `script`, or `brief`) and exactly one
-output (`text`, `script`, or `json`). Structured prompt inputs contain
+output (`text`, `script`, `json`, or a structured `object`).
+
+An optional second `text` input can carry the user's own instructions, such as
+decision rules or what to write: name it in `"prompt": {"$input": "data",
+"$instructions": "rules"}`. StillMade sends `Instructions:` then `Input:`.
+
+For a structured answer, declare one `object` output with a flat `schema` of up
+to 20 `string`, `number`, `integer` or `boolean` fields, for example
+`{"yes":"boolean","score":"integer","label":"string","reason":"string"}`.
+StillMade asks the model for exactly one JSON object with those fields, accepts
+the common `"85"` and `"true"` string forms, drops undeclared fields and fails the
+run when a field is missing. Fixtures for an object output use
+`{"kind":"object"}`; the declared fields are always checked. Later Steps can use
+the fields directly, for example with "Continue only if". Structured prompt inputs contain
 `{"schemaVersion":1,"text":"..."}`. A generated script returns that same
 structured shape; a text output returns a string. Typed ports, primary markers,
 semantic roles, and scoped project context retain their SDK meaning. A context
@@ -5536,6 +5604,21 @@ compatible({type: 'image', role: 'source_image'},
 ### Primary ports
 Declare one primary input and output for automatic insertion. A sole port is inferred for older packages. Multiple candidates without a declared primary do not produce an arbitrary connection.
 
+### How a project flags connection problems
+Every surface that shows a project's Blocks (the step rail, Flow cards, the Flow map and Canvas nodes) reads one classifier, `placementAttention` in `packages/block-platform/placement-attention.js`. It only explains states the flow inspection already proved; it never changes what may run. Order suggestions keep their own marker between the two Blocks and do not color either Block.
+
+| Glow | Meaning | Causes |
+| --- | --- | --- |
+| Red | Needs a fix before it can run correctly | Last run failed; result wasn't saved; Block unavailable; Blocks disagree on a contract or depend on each other; a connection points to a missing Block or input; a chosen source stopped working (pinned version gone, saved setting in the wrong format, two Canvas sources for one input); an input requires project information but allows no project source |
+| Yellow | Can continue once the person answers, reviews or reruns | A required input has no source yet; an unlabeled connection needs review; a schedule needs the owner to enable it; an earlier Block changed, so the result is outdated |
+| None | Normal sequencing | Waiting for an earlier Block, working, paused, skipped by a condition, private, finished, or Flow details unavailable |
+
+What authors control:
+- Give every port a `semantic`. A connection whose ports carry no meaning stays yellow until a person reviews it.
+- Mark settings with safe defaults `required: false`. Each required input without a source keeps the Block yellow until it is answered.
+- Allow the sources an input can really use (`user`, `chat`, `project`). A required input that needs project information but allows no project source is red.
+- Return outputs that match their declared type. A mismatched output fails the run, which turns the Block red.
+
 ### Safe connection conversions
 StillMade can insert a versioned, deterministic conversion between compatible
 Steps. This is part of the host connection contract; it does not add a visible
@@ -5645,6 +5728,21 @@ the host's existing media inputs or declared project context. Declaration alone
 is not permission. The host checks the full reference identity and current
 account/selection before transferring bytes. Detached history views can download
 text-only results; media ZIPs need the Block's current authorized media context.
+
+Source-project ZIPs may also contain bounded UTF-8 HTML, CSS, JavaScript,
+TypeScript, SVG and other common source text files as `{path,text}` members. The
+host treats those members as inert data, checks their paths and total size, and
+offers only the ZIP download after the normal export authorization. A single
+HTML or script file cannot be returned as `format: "file"`. Declare a useful
+semantic such as `web_source_project` so Revolver can connect the complete
+project to a compatible consumer. Binary files are not accepted as text members;
+use authorized media references where appropriate and do not omit required
+project files while claiming a complete export.
+For browser-application Blocks, `file-bundle` members must currently be
+text-only. The browser execution host rejects guest-supplied media references
+even when the manifest requests `asset.read`, because that request does not
+prove the current project selected the exact asset and version. Other Block
+runtimes retain their existing host-authorized media-bundle path.
 Unavailable, unselected or unsupported media aborts the ZIP instead of returning
 an archive with missing members. The host does not install dependencies.
 
@@ -5751,6 +5849,7 @@ export * from './workflow-approvals.js';
 export * from './package-semantics.js';
 export * from './define-block.js';
 export * from './adapter-registry.js';
+export * from './native-application-package.js';
 export * from './block-storage.js';
 export type {BlockViewDocumentTools,DocumentDraftOperation,DocumentEntry,DocumentPath} from './document-drafts.js';
 export type {BlockViewDocumentOptions,BlockViewDocumentConnection} from './document-store-binding.js';
@@ -5771,7 +5870,7 @@ export interface Manifest {
   /** Events the Block can run on by itself, once the project owner turns them on. */
   triggers?: import('./triggers.js').BlockTrigger[];
   semantics?: import('./semantic-contracts.js').SemanticDefinition[];
-  provenance?: { remixSource?: BlockPackage; remixPolicy?: {allowRemixing: boolean; sourceInspection?: "yes"|"no"|"license-controlled"}; remixAncestors?: {id: string; version: string; digest: string}[]; remixedFrom?: { id: string; version: string; digest: string }; [key: string]: unknown };
+  provenance?: { remixSource?: BlockPackage; remixPolicy?: {allowRemixing: boolean; sourceInspection?: "yes"|"no"|"license-controlled"}; remixAncestors?: {id: string; version: string; digest: string}[]; remixedFrom?: { id: string; version: string; digest: string }; githubSource?: {repository: string; commit: string; path: string}; [key: string]: unknown };
   summary?: Record<string, unknown>;
   license?: string;
   category?: string;
@@ -6416,6 +6515,24 @@ export function gainFor(measuredLufs: number, peak: number, targetLufs?: number)
 export function wavWriter(channelCount: number, sampleRate: number, frames: number): Readonly<{buffer: ArrayBuffer; write(channels: Float32Array[], from?: number, to?: number, gain?: number): void}>;
 export function encodeWav(channels: Float32Array[], sampleRate: number): ArrayBuffer;
 export function decodeWav(buffer: ArrayBuffer): {channels: Float32Array[]; sampleRate: number};
+/** Browser application bundle profiles. They describe a bundle format, not runtime admission.
+ * `desktop-browser-application/2` adds srcdoc frames (features: wasm, srcdocFrames);
+ * `desktop-browser-application/3` also declares local Web Workers (features: wasm, srcdocFrames, localWorkers: true). */
+export const BROWSER_APPLICATION_EMBEDDED_PROFILE:'desktop-browser-application/2';
+export const BROWSER_APPLICATION_LOCAL_WORKER_PROFILE:'desktop-browser-application/3';
+/** Content digests of a validated browser application package: packageDigest covers the whole package, bundleDigest only its application bundle. */
+export function getBrowserApplicationSourceDigests(value:unknown,options?:{signal?:AbortSignal}):Promise<Readonly<{packageDigest:string;bundleDigest:string}>>;
+/** Static check that every input and output declares a semantic meaning, whether it is required, a description, and a field schema for json/object outputs, so the Block can take part in typed resolution. runtimeVerified is always false. */
+export function reviewResolverContract(pkg:unknown):{name:string;runtimeVerified:false;contract:'semantic-resolver/1';passed:boolean;code?:'RESOLVER_CONTRACT';issues?:string[];message:string;manual?:{inputs:Array<{name:string;type:string;semantic:string;required:boolean;sources:string[]}>;outputs:Array<{name:string;type:string;semantic:string}>}};
+/** Native (desktop-only) application packages: exactly { manifest, nativeApplication }, bound to an exact GitHub source pin.
+ * Ordinary SDK execution and admission refuse them (NATIVE_APPLICATION_RUNTIME_UNAVAILABLE); installation needs host-verified
+ * admission bound to the exact source and runtime plus a managed interactive runtime. See NATIVE_APPLICATION_ADAPTATION.md. */
+export const NATIVE_APPLICATION_PACKAGE_CONTRACT:'native-application-package/1';
+export const NATIVE_APPLICATION_PACKAGE_LIMITS:Readonly<{packageBytes:262144;manifestBytes:65536;adapterBytes:64000;adapterFiles:8;ports:16;operations:16;capturedFiles:8}>;
+export const NATIVE_APPLICATION_RUNTIME_REQUIREMENT:string;
+/** Validates a native application package's strict source syntax and returns its detached, frozen copy. Throws NATIVE_APPLICATION_PACKAGE errors. Not runtime admission. */
+export function defineNativeApplicationPackage<T=unknown>(value:T):T;
+export function validateNativeApplicationPackage(value:unknown):true;
 
 ```
 
@@ -6567,7 +6684,7 @@ A portable image reference is not decoded pixel data. The host must resolve it b
 5. Test actual supported media in the host workspace.
 
 ### Every SDK error code
-Generated from the SDK source (194 codes). The message is one example; the actual message names the exact field or limit.
+Generated from the SDK source (197 codes). The message is one example; the actual message names the exact field or limit.
 
 | Code | Example message | Raised in |
 | --- | --- | --- |
@@ -6593,6 +6710,8 @@ Generated from the SDK source (194 codes). The message is one example; the actua
 | APPLICATION_GUEST_SIGNAL | Use an AbortSignal when supplied. | `browser-application-guest` |
 | APPLICATION_GUEST_STATE | Supply the host state revision. | `browser-application-guest` |
 | APPLICATION_INTEGRITY | Application artifact byte count differs from its reference. | `browser-application-artifacts` |
+| APPLICATION_OUTPUT_CANDIDATE | Use declared browser application outputs. | `browser-application-output-policy` |
+| APPLICATION_OUTPUT_UNMATERIALIZED | Output … includes media references that the browser application host has not independently verified. | `browser-application-output-policy` |
 | APPLICATION_SOURCE_LIMIT | Application source | `browser-application-artifacts` |
 | APPLICATION_SOURCE_REFERENCE | Use a browser application manifest. | `browser-application-artifacts` |
 | APPLICATION_STATE_LIMIT | Application state artifact | `browser-application-artifacts` |
@@ -6602,6 +6721,7 @@ Generated from the SDK source (194 codes). The message is one example; the actua
 | AUDIO_SCORE_HOST | Choose a supported Audio Score operation | `audio-score-host` |
 | BEHAVIOR | Output differs from expected fixture. Expected …; received … | `testing` |
 | BROWSER_APPLICATION_UNAVAILABLE | No trusted desktop browser application executor is installed. A bundle or mounted interface is not execution. | `browser-application-execution` |
+| BROWSER_BUILD_DEPENDENCY | Expected one exact registry tarball identity. | `repository-build-dependencies` |
 | BUSY | JavaScript runners are busy. Try again shortly. | `sandbox-node` |
 | BYOK_PAYMENT_HOST | Choose a supported payment capability | `byok-payment-host` |
 | CANCELLED | Conversion stopped. | `adapter-registry`, `browser-application-execution`, `browser-application-guest` and 7 more |
@@ -6657,6 +6777,7 @@ Generated from the SDK source (194 codes). The message is one example; the actua
 | DOCUMENT_SOURCE_CONFLICT | Project source changed underneath the shared draft. Review and explicitly reset the shared draft for everyone, or supply a compatible source. | `document-store` |
 | DOCUMENT_STORE | Use a bounded named document field | `document-store` |
 | FIRST_PARTY_SOURCE | Use the exact published first-party package before creating a remix. | `remix-policy`, `testing` |
+| GENERATION_SETTINGS | This Step does not generate images, video or speech. | `generation-settings` |
 | HOST_SERVICES | Animated assets requires its version 1 generation and dialog host | `animated-assets-host`, `asset-generation-host`, `blueprint-host-services` and 47 more |
 | INPUT_SOURCE | … does not allow … information. Choose a permitted source. | `input-source-policy` |
 | JOB_EXECUTOR | Use a trusted host executor | `package-jobs` |
@@ -6669,7 +6790,6 @@ Generated from the SDK source (194 codes). The message is one example; the actua
 | LICENSE_RESTRICTED | Conflicting file-level SPDX license at … | `portable-github`, `portable` |
 | LIMIT | Source exceeds static review complexity | `admission`, `browser-application-execution`, `capabilities` and 14 more |
 | LINEAGE | Declare lineage {parents:[{id,version,digest}],changes} | `portable` |
-| LOCAL_WORKER_REQUIRED | Pair a reviewed local worker for this application. A browser or desktop download alone cannot execute its native source. | `runtime` |
 | MANIFEST | Invalid JavaScript manifest | `javascript` |
 | MEDIA_DESCRIPTION_HOST | Describe Media requires a supported image reference and optional hint | `media-description-host` |
 | MEDIA_RENDER_INPUT | Final render requires a versioned timeline, settings, and Block source. | `portable-media-contracts` |
@@ -7034,6 +7154,8 @@ Blocks, Project Types, and creators have their own page URLs. Public pages link
 
 ## Build with an AI coding tool
 
+The fastest route is to send your coding agent [Build a Block with your AI](/docs/build/with-your-ai) with your idea: it downloads the SDK, builds the Block and runs the readiness gate without you running anything.
+
 ### Start with the SDK contract
 Use the button below to copy the complete authoring guide, then add a short description such as “Make a Block that converts an image to grayscale while preserving alpha.” The guide includes the package format, supported runtime, typed ports, permissions, fixtures, and a complete example.
 
@@ -7048,9 +7170,9 @@ Ask the assistant to return source files or one `.stillmade.json` package. Run t
 
 <!-- builder-contract:start (generated by npm run build:sdk; do not edit) -->
 
-### Block builder contract (stillmade.block-builder@1.0.0)
+### Block builder contract (stillmade.block-builder@1.3.0)
 
-Contract `stillmade.block-builder@1.0.0`. Humans, coding agents, imported source, GitHub repositories and generated code all adapt to the Block platform; anything that becomes a StillMade Block obeys this contract.
+Contract `stillmade.block-builder@1.3.0`. Humans, coding agents, imported source, GitHub repositories and generated code all adapt to the Block platform; anything that becomes a StillMade Block obeys this contract.
 
 ### Source of truth
 
@@ -7060,13 +7182,27 @@ Treat the current SDK (`stillmade.block.json` manifest, `packages/block-sdk` con
 
 Before building, check what already exists (`find_existing_blocks` over MCP, or the Marketplace and your library) by the inputs, results and operations the goal needs. Use an installed or reviewed Block that already does it; remix a close one so its license, notices and creator credit stay attached; chain existing Blocks and build only the missing step. Never republish another creator's source without remix lineage: public copies are refused. Build a new Block when nothing fits or the person asks for their own version, and say which similar Blocks you considered.
 
+### One job per Step
+
+A Step is one job: the work between two moments where a person or the outside world must see the result. Start a new Step only at one of three points; everything else is a part of the neighboring Step.
+
+1. **A person works with the result**: reads, edits, picks or approves it (a workspace Block such as a script, a Canvas or an Editor, or an approval). That is why Chat, Bible, Canvas and Editor are four Steps.
+2. **Finding new things turns into handling each one**: the trigger (a schedule or an app event), the app read, its filter and "only new" are the first job; what is done with each item is the next job. A trigger is a setting of the first job, never a Step of its own.
+3. **The result leaves StillMade**: it is sent, posted, published, paid or written into another app. Consecutive writes to the same app, with the glue that shapes data for them, are one job.
+
+A part that only runs in the desktop app cannot share a Step with cloud parts. Before adding a Step, name which of the three reasons makes it separate; if none applies, make it a part of a neighbor. A Step nobody would ever open must not exist on its own. Prefer an app task's own filter (a Gmail query such as `has:attachment filename:png`) to an AI check, and use AI decide only for judgement.
+
+Inside one job, each capability stays its own part: a capability Block performs exactly one hosted operation and a connector one app task, so every part keeps its own permission, approval and credit rules, and StillMade groups the parts of one job into one Step (`groups` in the Project Type). Never invent a combined runtime. When one Block can do the whole job with documented primitives (a JavaScript Block doing several local transforms, a workspace owning its whole document), build it as one Block.
+
+Examples: "every new email with an image becomes a generated image" is two Steps, "Gmail · New emails with images" (When, fetch with an image filter, only new) and "Image from email" (AI write, Generate image); listing When, Fetch, Only new, AI decide, Continue only if, AI write and Generate image as seven Steps splits one job into its parts. "A new Meta lead goes to HubSpot" is three Steps: "Meta Ads · New leads", "Qualify lead" and "HubSpot · Add contact".
+
 ### Define the capability first
 
-Translate the request into an explicit capability contract before implementation: what the Block does; each input with its type, meaning and whether it is required (prefer optional settings with safe defaults over extra required questions); each output with its type and meaning; persistent state; project context it reads; permissions; UI; long-running behavior; expected failures; cancellation; determinism; and whether it needs hosted models, media, desktop tools or shared editing. Keep the public interface as small and general as possible and keep implementation details out of it.
+Translate the request into an explicit capability contract before implementation: what the Block does; each input with its type, meaning and whether it is required (prefer optional settings with safe defaults over extra required questions); each output with its type and meaning; persistent state; project context it reads; permissions; UI; long-running behavior; expected failures; cancellation; determinism; and whether it needs hosted models, media, desktop tools or shared editing. Keep the public interface as small and general as possible (few required inputs, one primary output) and keep implementation details out of it; small means a small interface, never a fragment of a job. A Block that generates images, video or speech declares only its prompt and output: every Step that runs it gets the host’s generation settings (model, quality, length and resolution, voice, speed, how many), saved with the Step, changed on its page or by Chat, and shown with their cost before each run.
 
 ### Blocks compose
 
-A Block is not a mini-app. Its outputs become other Blocks' inputs and its inputs come from other Blocks, project context or the user. Use the typed port system: shared StillMade types (`image`, `video`, `audio`, `asset`, `script`, `shot[]`, ...), a `semantic` meaning on every port, `required` and a short `description`. Mark exactly one primary input and one primary output so Project Type Steps connect automatically, and use `kind: "task"`: a `workspace` Block owns a project document and is never connected automatically. Inputs marked `context` read the project and cannot receive a connection from another Step. Output reusable StillMade values: media references (`{kind,assetId,versionId,url}`) and structured production values with `schemaVersion: 1`, preserving provenance, versions and relationships downstream Blocks need. Never make ordinary users wire JSON, copy IDs, understand internal paths or translate one Block's output into another: `createUniversalResolver()` (the same engine as the Project Type composer) resolves inputs from compatible upstream outputs, permitted project context and, for optional non-context inputs, `StillMade.requestFromUser`.
+A Block is one job: not a mini-app of many jobs and not a fragment of one. Its outputs become other Blocks' inputs and its inputs come from other Blocks, project context or the user. Use the typed port system: shared StillMade types (`image`, `video`, `audio`, `asset`, `script`, `shot[]`, ...), a `semantic` meaning on every port, `required` and a short `description`. Mark exactly one primary input and one primary output so Project Type Steps connect automatically, and use `kind: "task"`: a `workspace` Block owns a project document and is never connected automatically. Inputs marked `context` read the project and cannot receive a connection from another Step. Output reusable StillMade values: media references (`{kind,assetId,versionId,url}`) and structured production values with `schemaVersion: 1`, preserving provenance, versions and relationships downstream Blocks need. Never make ordinary users wire JSON, copy IDs, understand internal paths or translate one Block's output into another: `createUniversalResolver()` (the same engine as the Project Type composer) resolves inputs from compatible upstream outputs, permitted project context and, for optional non-context inputs, `StillMade.requestFromUser`.
 
 ### Use platform primitives
 
@@ -7076,9 +7212,13 @@ Prefer, in order: an SDK capability; a documented host capability (the hosted op
 
 Never make a Block look functional through hard-coded local paths, developer-machine dependencies, undocumented environment variables, admin or database access, hidden core modifications, direct database writes, fake or mocked production results, hand-prepared test assets that hide incompatibilities, credentials in code, or assumptions about one user's machine. The finished Block must work through the same interfaces available to any installed Block; `permissions.network`, `permissions.filesystem` and `permissions.secrets` must be empty arrays.
 
+### Name it briefly
+
+Give the Block a short, plain name of 40 characters or fewer that says what it does ("Captioned Clip", not "Captioned Business Clip Generator With Review"). The name appears in step bars, Project Type cards and pickers, so put the detail in the description instead. New releases with a longer name do not pass readiness.
+
 ### Interface
 
-If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction genuinely needs one. Expose the capability, not the implementation: meaningful controls, sensible defaults, preview, direct manipulation, progress, clear errors and visible outputs. Do not show raw JSON, internal IDs, filesystem details, provider terminology or developer settings unless the Block is itself a developer tool. Follow the host appearance (Light, Dark and White) and the mobile layout contract: one interface for every screen size that fits a 320 CSS-pixel phone without horizontal scrolling.
+If the capability needs UI, use the Block UI SDK: generated `manifest.ui` controls first; a sandboxed custom view (`view.html`/`view.css`/`view.js`) only when the core interaction genuinely needs one. Expose the capability, not the implementation: meaningful controls, sensible defaults, preview, direct manipulation, progress, clear errors and visible outputs. Do not show raw JSON, internal IDs, filesystem details, provider terminology or developer settings unless the Block is itself a developer tool. When a person chooses among options they need to hear or see (voices, music, sounds, fonts, looks, colors, templates or images), let them preview each option before choosing: a sample to play or a thumbnail, from the Block's own files or the host's free samples, never a paid generation. Leave previews out only when the builder states there is nothing to preview. Choices StillMade owns, such as voices and models in the run review, already show their samples. Follow the host appearance (Light, Dark and White) and the mobile layout contract: one interface for every screen size that fits a 320 CSS-pixel phone without horizontal scrolling.
 
 ### Shared editing
 
@@ -7114,11 +7254,11 @@ StillMade runs the readiness check on every Block it admits: manifest and contra
 
 ### Project Types
 
-A Project Type is an ordered production workflow. Each Step's primary output must be a compatible input for the next Step, secondary values come from permitted project context, and every member Block obeys this contract. Install Blocks into a realistic Project Type: project chat must understand each Step, inputs must resolve intuitively, outputs and execution state must be visible, failures must be diagnosable, and the user must be able to continue through the workflow.
+A Project Type is an ordered production workflow. Each Step's primary output must be a compatible input for the next Step, secondary values come from permitted project context, and every member Block obeys this contract. Install Blocks into a realistic Project Type: project chat must understand each Step, inputs must resolve intuitively, outputs and execution state must be visible, failures must be diagnosable, and the user must be able to continue through the workflow. Group the parts of one job into one Step instead of listing helper parts as Steps; most automations are two to four Steps.
 
 ### Readiness report
 
-Finish with a Block Readiness Report: capability, contract (inputs, outputs, permissions, dependencies), platform APIs used, tests actually performed and their results, the composition test (upstream, Block, downstream), known limitations, unsupported requirements and any platform gap with its smallest general primitive. Choose exactly one status: PRODUCTION READY (every applicable check passed), READY WITH DOCUMENTED LIMITATIONS (works reliably within stated boundaries), BLOCKED BY PLATFORM CAPABILITY (needs a missing generic primitive) or FAILED. Never label a Block production ready to satisfy a request, and never claim a check ran when it did not.
+Finish with a Block Readiness Report: capability, contract (inputs, outputs, permissions, dependencies), platform APIs used, tests actually performed and their results, the composition test (upstream, Block, downstream), known limitations, unsupported requirements and any platform gap with its smallest general primitive. Report exactly one status, the one StillMade's readiness check returned (`ready` in the SDK CLI, `check_block_readiness` over MCP), never one you chose: PRODUCTION READY (every applicable check passed), READY WITH DOCUMENTED LIMITATIONS (works reliably within stated boundaries), BLOCKED BY PLATFORM CAPABILITY (needs a missing generic primitive) or FAILED. Never label a Block production ready to satisfy a request, and never claim a check ran when it did not.
 
 ### Definition of done
 
@@ -7394,9 +7534,10 @@ of the SDK URL the user supplied, not a guessed production hostname or localhost
 - Search `/api/public-listings/discover?kind=block&search=<encoded-query>` for
   Blocks, or use `kind=type` for Project Types. Follow `nextCursor` with `after`
   when more results are relevant; a single page is not the complete catalog.
-- Use returned listing identities and versions to inspect
-  `/api/public-listings/<kind>/<id>/<version>/source.json` where source inspection
-  is permitted. Read the real manifest and any declared dependency packages.
+- Use returned listing identities and versions to read
+  `/api/public-listings/<kind>/<id>/<version>/metadata.json`: its name, description
+  and typed inputs and outputs. A Block's code is private to its creator, so build
+  on what it takes and makes, never on its source.
 - In an offline SDK checkout, `packages/block-platform/catalog.js` provides bundled
   first-party examples. It is a snapshot, not the complete live Marketplace.
 
@@ -9452,8 +9593,98 @@ The in-app full-application inspection pins source and retains an inventory of
 code, binary assets, dependency manifests, lockfiles, symlinks and submodules.
 It returns `not-built`, including unfinished feature and runtime checks. A complete
 file inventory is neither a complete dependency checkout nor a successful build.
-Inspection uses public unauthenticated GitHub APIs; it does not authorize private
+Inspection first uses public unauthenticated GitHub APIs; it does not authorize private
 repository access, install dependencies, execute scripts or charge model credits.
+An exact commit's complete, verified public tree and Git-blob-checked source
+bytes may be reused from a 15-minute, 24 MiB process-local cache across the
+inspection, build and source-recheck phases. Branch/HEAD resolution, partial
+trees, failed reads and unverified bytes are not cached. Source review reports
+`pinned-cache` when it uses that evidence instead of claiming a fresh API read.
+The cache avoids repeated anonymous requests for one pin; a cold repository
+still depends on GitHub availability and its rate limit, and another server
+process has its own cache. It is not a substitute for an authenticated or
+archive-backed source acquisition route at larger scale.
+When the public REST API is rate-limited, the application import can instead
+resolve the public branch or tag through bounded Git protocol v2 HTTP and inspect a
+GitHub codeload archive at the resulting commit. The host checks the archive's
+commit marker, tar structure and paths, computes Git blob identities from
+actual bytes, rejects sensitive or oversized selected files, and labels this
+evidence `pinned-github-archive`. A named ref uses two bounded Git HTTP requests
+before the archive request; an exact commit needs only the archive request.
+This fallback is capped at 12 MB compressed and 40 MB expanded, requires no
+Git executable on the server, and refuses repositories with
+submodules because the archive omits their Git identities. Larger archives
+must use the Git tree route or a future bounded acquisition worker. Archive
+inspection is source evidence only; it does not approve execution or install.
+The REST and fallback phases use the same caller-owned HTTP transport when one
+is provided. Reported request use includes both phases. Reported byte use
+includes REST and archive bodies; the two Git-ref responses have separate
+64 KiB limits and are not included in that aggregate byte figure.
+For a complete Git tree containing submodules, inspection reads the pinned
+`.gitmodules` blob, accepts only canonical or relative GitHub repositories,
+and follows each exact Gitlink commit (including nested modules) within one
+48-request, 32 MB metadata and 24-placement bound. It reports each dependency
+commit separately. This verifies dependency identities and file inventories;
+the isolated builder must still acquire and hash the actual dependency bytes
+before running their code. Missing mappings, outside hosts, incomplete trees
+and exhausted bounds fail with a specific source-graph reason.
+The larger isolated-build acquisition profile can verify a complete archive
+against that Git tree, including ordinary files and symlink identities. GitHub
+codeload can omit files under `export-ignore` or transform exported text; those
+paths must be restored from exact-commit raw transport and independently
+rehashed to their pinned Git blobs. The raw route is limited to 64 files and
+8 MB, denies sensitive paths, uses no credentials or redirects, and cannot
+grant execution. All archive and recovered bytes are checked before a trusted
+staging callback receives any file. This profile has not yet been connected
+to a complete native build or installation workflow.
+The inspection `readable` flag controls what the LLM can request as source
+text. It is not a build-file filter. A separately checked `stageable` flag
+allows oversized but bounded files and inert symlink-target blobs into the
+private build-source quarantine; sensitive paths remain excluded. Symlink
+targets are stored as bytes, not followed or created as active filesystem
+links. A later materializer must validate every link target before use.
+The isolated-worker source-closure orchestrator groups identical pinned
+repositories across submodule placements, rechecks each exact commit, and
+hands verified bytes to a trusted quarantined staging callback under one
+request, network-byte, file, staged-byte and deadline budget. Its receipt is
+`execution:not-run` and `installable:false`; a partial stage has no activation
+authority. The connected private staging writer uses content-addressed inert
+blobs and rereads each file before sealing it. A complete closure produces a
+read-only manifest bound to a host-retained digest; reopening the quarantine
+audits every blob against its Git identity. Partial stages cannot be sealed.
+The inert tree planner checks file/directory namespace collisions and resolves
+symlink targets only within the exact staged closure, without expanding source
+paths on the host filesystem. A bounded transfer format then packs each
+audited Git blob once and binds its canonical namespace, modes, link targets,
+source digest and sealed-manifest digest into a SHA-256 bundle. The Linux
+materializer independently verifies the bundle and Git hashes, creates files
+through private directory descriptors, creates links only after file writes,
+and audits the final tree. A synthetic tree with an executable and links ran
+in the isolated VM; a changed bundle was rejected before staging. Natron's
+allowed exact closure also materialized there: 6,445 files and 654 directories.
+This development path is not yet a trusted install or execution admission:
+the stage owner can still change its read-only modes, and build recipes,
+dependencies, GUI sessions and result contracts need separate host control.
+For an npm browser candidate, inspection also reads the pinned `package.json` and
+`package-lock.json` through the same bounded source verifier. It checks that root
+dependency declarations agree and distinguishes integrity-pinned npm tarballs,
+exact-commit GitHub dependencies and unresolved sources. This is a build plan,
+not dependency acquisition or build admission. The pinned miniPaint case has
+517 npm tarballs and one exact-commit GitHub dependency; an isolated builder
+must acquire and verify both kinds before executing its Webpack build.
+Before rebuilding, the importer checks whether the pinned repository already
+contains an HTML entry referencing a checked-in local browser bundle. It selects
+the referenced scripts/styles and bounded local media resources, then verifies
+every selected byte against the Git tree. This can preserve a real original UI
+without executing a package script. It is still only a candidate: dynamic
+resource requests, operations, state and output must pass isolated review.
+miniPaint's checked-in bundle passed a separate local browser probe with a real
+brush stroke, changed PNG bytes and exact document restore in a second page.
+That probe is not an installed Block or a host-enforced multiplayer result.
+The local acquisition module also re-read miniPaint's exact pinned lockfile and
+verified all 518 dependencies (about 18.2 MB) against registry SHA-512 or Git
+blob identities. Those bytes were discarded after the probe. A managed stage,
+isolated framework rebuild and reviewed execution admission are still missing.
 
 Use the exported `defineRepositoryApplication` contract to record the requested
 scope, interface, versioned route and source-backed feature ledger. Use
@@ -9463,6 +9694,80 @@ verification. The assessor always reports `executionPerformed:false` and
 `independentlyVerified:false`. A model cannot certify its own integration by
 filling in that object.
 
+For a generated browser application, put the exact GitHub repository URL,
+40-character commit and application folder in
+`manifest.provenance.githubSource`. The SDK checks its shape and the source
+reviewer independently matches it to the pinned Git tree and every bundled
+original asset. This field travels with the versioned package; it is source
+identity, not permission, a license decision or evidence that the adapter ran.
+Older uninstalled candidates without the embedded pin can still undergo
+source review, but must not be promoted to production solely from that legacy
+shape.
+
+For a framework application built from pinned source, the unreviewed candidate
+also carries `manifest.provenance.browserBuild`: the verified source-closure
+digest, build-script digest, output directory and digest of every original
+compiled file. A model may author the lifecycle adapter, but cannot supply the
+build result or certify it. A trusted host must independently rederive the
+Git source closure, verify the exact isolated build and reconstruct the full
+application bundle before running the ordinary interface, state and output
+review. The current SDK handoff and internal verifier implement these checks;
+the production build supervisor and review issuer are not yet connected to the
+GitHub button. A build or source receipt alone does not make a Block installable.
+An internal npm job now composes the sealed source bundle, Linux materializer,
+integrity-pinned registry and exact-commit GitHub package stages, and the
+network-denied build runner. It checks each identity again between stages and
+returns compiled bytes with no installation authority. The Linux npm profile
+now caps selected packages at 768, verified expanded package bytes at 256 MiB,
+and package files at 18,000. It caps compiled files at 16 MiB total, each
+file at 8 MiB, and the encoded build report at 24 MiB, with a root `dist`,
+`build` or `out` entry. It
+omits a lockfile package only when that package is explicitly optional and
+incompatible with the worker's OS, CPU or libc; the root launcher rechecks
+that selection against the pinned lock before execution. It has not run
+miniPaint's build, and still needs the durable supervisor lease and cleanup
+needed for a production
+button. The stage-order tests are offline; no real framework repository has
+passed this composed job. The worker also exposes a trusted rebuild callback
+for the compiled-candidate source verifier; the caller must run it under the
+same host-owned supervisor rather than accepting a browser-supplied report.
+
+A successful framework build does not prove that all runtime assets are local.
+For example, CanvasCode compiled from its pinned source but loaded Monaco from
+a CDN; the isolated network-denied browser showed its preview while the editor
+remained unavailable. Manually bundling the already pinned Monaco dependency
+restored the editor and real ZIP export in an offline development VM. The
+internal compiled-authoring path can now ask a model for complete replacements
+or unique exact-text edits of inspected source files, each bound to its
+original Git SHA-256. The host derives full replacement bytes for an edit. A root-owned
+stage checks and seals replacement bytes separately from the immutable Git
+source; the network-denied build applies them in scratch space. Patch identity
+must match in the compiled candidate and an independent rebuild. Package
+manifests and lockfiles cannot be patched in this profile. The root-owned patch
+stage, service connection, automatic runtime-failure repair and full behavior
+review remain unverified. A model-suggested CDN exception is not equivalent to
+localizing and verifying those assets.
+CanvasCode also requires a `srcDoc` preview frame and local Monaco language
+workers. The original browser-application profile declares only single-thread
+WASM; its CSP and target guard deny frames and workers. A successful ordinary
+Chromium smoke therefore cannot establish host-runtime compatibility.
+
+The new browser-application v2 source profile now supports a declared, bounded
+direct `srcdoc` frame. The compiled authorer can request that feature, and
+independent source verification reconstructs the exact profile from the pinned
+build. A local Chromium probe confirmed that the v2 CSP runs an inline preview
+script, reports the expected direct child frame, and keeps the top-only trusted
+bootstrap out of the child. The existing v1 CSP and frame guard remain closed.
+This is development-browser evidence, not a provisioned StillMade worker run.
+CanvasCode also needs local Monaco language workers. Browser application v3
+now declares exact bundled dedicated worker scripts, and the trusted target
+policy admits them only when paused under the original page and context. A
+local Chrome probe ran a worker through that policy and the hashed asset
+server, while CSP denied a second loopback origin. The original v1 and v2
+profiles still deny workers. This is not a provisioned StillMade worker test,
+CanvasCode's own worker behavior has not passed runtime review, and its full
+application import remains uninstalled.
+
 ### Choose an actual runtime
 
 | Source | Current boundary |
@@ -9480,6 +9785,18 @@ adapter. The exact reviewed Method Draw source has a private desktop install,
 editing and SVG export path. Other applications require separate source,
 runtime and result review; package validation alone is insufficient.
 
+The separate Natron ARM64 development build (repository evidence `artifacts/repository-acceptance/natron-native-gui-dev-build-2026-09-29.json`)
+shows that a Qt5/PySide2 native GUI can compile and open in a local VM after
+architecture and Python-home adaptation. Its source tree is not yet the
+complete sealed Git closure, and its OCIO configs and OpenFX plugins are
+missing. This is runtime feasibility evidence, not approval to install a
+GitHub-authored Block or a replacement for the full application.
+The later exact-source-to-GUI check (repository evidence `artifacts/repository-acceptance/natron-exact-tree-to-gui-2026-09-29.json`)
+replaced that archive input with the verified allowed Git closure and compiled
+a separate copy carrying only the recorded ARM64 patch. The GUI opened; the
+same binary also saved and reopened a native `.ntp` project. The missing
+plugins, color config and host-enforced Block contracts remain.
+
 ### Keep the original appearance
 
 For an eligible restricted view, place this option in `src/view.json`:
@@ -9512,6 +9829,13 @@ contract and the complete runtime message limits. Large or referenced media
 still needs the host's authenticated asset resolution and materialization path;
 a guest-local data/blob URL is not a durable shared asset.
 
+For browser applications with several export actions, declare which output
+ports each action produces. An SVG export can map to `svg` and a PNG export to
+`png`; mark each shared-manifest port `required:false` when another action
+does not return it. The host checks the exact action-to-port mapping before
+publishing output or storing media. A generated adapter's declaration alone
+does not prove either export works.
+
 Map existing app behavior to SDK input, shared-document and output interfaces.
 Do not recreate the application's logic in the shared host or add a special
 Block-ID branch. Persist editable state through declared host services and keep
@@ -9603,6 +9927,32 @@ automatic permission. Arbitrary development servers, native Node modules,
 service workers, threaded WASM and full-stack backends need distinct profiles
 and verified host capabilities. Existing SDK restrictions are not removed.
 
+The separately identified `desktop-browser-application/2` bundle may declare
+`features: {wasm:false, srcdocFrames:true}`. A trusted stage and runtime use this
+exact declaration to enable at most eight simultaneous direct `about:srcdoc`
+frames (32 over the page lifetime), with inline script needed for a preview
+document. Other frame URLs, nested frames, popups and local web workers remain
+denied. The trusted controller bootstrap runs only in the top document. This
+profile does not authorize ambient network requests or installation; exact
+source review, isolated execution and output review still apply. An authoring
+model can request it, but it cannot enable it by changing a prompt or manifest.
+
+`desktop-browser-application/3` adds `localWorkers:true` (and an explicit
+`srcdocFrames` boolean). It permits only dedicated workers whose script URL
+exactly names a bundled JavaScript asset on the application asset server. The
+target policy binds each worker to the exact parent page and browser context,
+requires a paused attachment, installs recursive target monitoring before
+resume, limits active and lifetime workers, and fails the session on an unknown
+target or unconfirmed detach. The host-controlled CSP permits same-origin
+workers and same-origin connections; the asset server serves only verified
+bundled files. The isolated job's private network namespace remains required.
+Chrome does not expose `Fetch.enable` on worker CDP sessions, so worker egress
+is enforced by the host CSP, exact local asset server and private network
+boundary, not by a worker-session Fetch interceptor. Blob, remote, shared and
+service workers remain denied. A local Chromium probe exercises the target
+policy and asset server, including a denied second loopback origin. A
+provisioned StillMade worker run and application-level review remain required.
+
 Inspect compiled dependencies as well as asset extensions. For example, a
 checked-in editor bundle may contain base64 WebAssembly or dynamically create
 workers without shipping any `.wasm` file. The current asset/declaration check
@@ -9610,7 +9960,8 @@ does not prove those paths are absent. Admission must record which paths are
 needed, and the selected runtime must enforce its CSP, target and resource
 policy when code executes. A dead or explicitly unavailable feature is different
 from a verified fallback. The current development Linux worker rejects declared
-WASM and blocks worker creation; it does not establish general WASM support.
+WASM; the new worker profile has not been provisioned or admitted for an
+installed Block.
 
 ### Adapter lifecycle and completion
 
@@ -9620,6 +9971,47 @@ original application APIs and controls. Keep autosave separate from explicit
 completion; mounting a UI or retaining the original input is not evidence of
 the requested transformation.
 
+For compiled applications, inspect where the original UI owns its live state.
+If that state is private to a bundled module, a bounded source edit may expose
+a data-only bridge for the Block-owned adapter. The edit must target an exact
+inspected pinned file and be rebuilt under the sealed source identity. The
+adapter should seed inputs and restore checkpoints through the original state
+path, then export the state changed by real UI actions. A global store bridge
+is not itself host storage or permission authority. Include binary project
+files or fail explicitly; silently dropping them makes saved state and export
+incomplete. Declare structured output meaning and schema so Revolver can
+distinguish a website-source project from arbitrary JSON. Browser-downloaded
+ZIP bytes are not a connected artifact until a trusted host materializer owns
+and validates them; a JSON/base64 field must not be presented as a ZIP.
+
+The candidate reviewer can perturb a primary `plain_text` input, or insert a
+valid HTML comment into a primary `html_document` input, in a fresh isolated
+session. It compares only declared text or schema-bearing structured output
+ports for the same export operation. A fixed JSON project now fails this check
+even when its original UI and save/reopen path appear to work. An arbitrary
+custom text format does not receive a guessed mutation. This diagnostic checks
+that output responds to changed input; it does not establish that the result
+has the correct application-specific meaning.
+
+When a Block receives an upstream value and also stores user edits, checkpoint
+both the editable document and the upstream value that seeded it. Reopen edits
+only when the mounted upstream value still matches; otherwise apply the new
+upstream value and rerun the original application's render path. A model must
+not treat the application's `localStorage` as the host's project or placement
+state. If rendering is debounced or asynchronous, `mount` must wait for the
+new result (or a real error) before acknowledging success, and `execute` must
+read the completed original result rather than an old preview. Runtime review
+should vary the input after a saved edit to catch stale-result replay.
+
+Exercise original export buttons under the exact runtime CSP as well as the
+declared adapter operations. Displaying SVG is weaker evidence than exporting
+PNG: embedded XHTML `foreignObject` labels can taint the canvas when that SVG
+is rasterized. An adapter may repair the original action with a bounded,
+reviewed conversion, but must compare the visible result and downloaded bytes.
+An operation that succeeds while the corresponding original control fails does
+not establish a preserved application interface. Clipboard actions require a
+separate approved capability and behavioral review.
+
 `prepareBrowserApplicationMount` binds a mount request to the exact package,
 bundle, input and state revision. A mount acknowledgement carries no outputs and
 cannot pass execution validation.
@@ -9632,21 +10024,70 @@ current permission/state checks. `validateBrowserApplicationExecutionResult`
 and the saved-record validator check those bindings; their result explicitly
 keeps `independentlyVerified:false`. Arbitrary callers can fabricate JSON, so
 these pure helpers do not authenticate evidence or authorize adoption.
+An application package must declare at least one typed output, and each
+completed operation must actually return at least one declared output even if
+the port is optional. A nonempty value can still be semantically wrong; review
+must compare representative saved and exported results with the original app.
 
 `runBrowserApplication` requires an explicitly supplied trusted executor. It
 never falls back to evaluating source in the host or treating a mounted page as
 success. Cancellation and timeout signal the executor; actual process/resource
 termination is the executor's responsibility and needs independent verification.
 
+### Media output candidates
+
+An adapter exporting an `image` port returns actual PNG bytes as
+`{encoding:"base64",mimeType:"image/png",data:"..."}`. It must never return an
+`assetId`, `versionId`, URL or receipt of its own. The worker checks the shape
+and keeps the result an **untrusted candidate**. The host-side
+`materializeBrowserApplicationOutputs` boundary decodes and checks the image,
+writes it through trusted storage, reads back the exact bytes, checks the current
+execution revision again, and only then creates the typed image reference that
+Revolver can carry. Other media types still require materializers. The local
+worker, browser-control pipe and guest output envelope now each accept a
+bounded 4 MiB PNG after base64 encoding inside an 8 MiB frame; the session
+traffic cap is 32 MiB. Inputs and saved state retain their smaller limits.
+Large candidate transport was checked offline across those layers, while
+miniPaint's real PNG was separately decoded and materialized. A durable S3
+output adapter exists but is not wired into installed production execution.
+Installed image executions now reserve an 8 MiB aggregate maximum in the
+server-owned ledger before dispatch, under the account-wide lock. The
+reservation is compared with the account's storage-plan allotment and remains
+charged if dispatch becomes uncertain. A reservation proven never dispatched
+can be closed without consuming capacity. A completed run records verified
+stored bytes. This ledger measures application outputs separately from other
+project media; output deletion and plan-wide reconciliation still need the
+production lifecycle before enabling installed image exports.
+The desktop session now accepts a host-only `store.materializeOutputs` callback
+between isolated execution and completion. It rejects guest-minted image asset
+IDs before that callback, supplies the exact request and current authority
+binding, rechecks access afterward, and accepts only a valid typed result.
+The manager forwards this callback from trusted main-process composition; a
+real PNG was tested through decode, write, readback and receipt validation,
+including revocation after storage read. The installed HTTP host does not yet
+supply a media store, so this is a supported host boundary, not a production
+image export claim. Candidate review also lacks that store today.
+
 ### Guest registration
 
-`installBrowserApplicationGuest({target,operations,messageBytes})` is the
+`installBrowserApplicationGuest({target,operations,messageBytes,outputBytes})` is the
 framework-neutral lifecycle dispatcher for a trusted bootstrap. It installs only
 `target.stillmadeApplication.register(adapter)` and returns a separate controller
-to that bootstrap. It does not install a runtime or grant host access.
+to that bootstrap. The host may select a larger output-only envelope up to
+8 MiB; the ordinary message limit still applies to inputs and saved state.
+It does not install a runtime or grant host access.
 
 The Block-owned adapter registers exactly these four methods once:
 
+For a new application with several export choices, each bundle operation maps
+to the output ports it actually produces, for example
+`{id:"png.export",kind:"export",outputs:["png"]}`. Ports absent from some
+operations must declare `required:false` in the shared manifest. The host
+requires every mapped operation to return exactly its listed ports before
+materializing media or committing a completion. Older bundles with only
+`{id,kind}` retain their original contract; the new mapping is additive and
+does not change published package bytes.
+
 | Method | Adapter result |
 | --- | --- |
 | `mount({inputs,state,signal})` | Restore the original UI and return exactly `{mounted:true}`. |
@@ -9690,6 +10131,14 @@ Method Draw is being used to study the first complete static editor route.
 Its remote fonts, global localStorage and SVG import behavior require explicit
 adaptation; an original-page baseline is not a completed Block integration.
 
+The worker now has a separate **candidate-review** stage identity for an
+unlisted, digest-verified browser package. Its driver and unit entry are selected
+by trusted code, while the installed supervisor and runner retain the exact
+reviewed-source registry. This is the source boundary needed to test generated
+adapters without editing a per-repository allowlist. A root-owned review
+supervisor, complete behavior gate, and admission-to-install handoff are still
+missing; staging a candidate does not run or install it.
+
 ### Reproduce the reviewed package outside the repository
 
 The downloadable SDK zip includes `packages/block-sdk/browser-application.js`
@@ -10387,7 +10836,9 @@ copyright holders, repository commits or permission. Unresolved rights produce a
 blocked result. Never silently license someone else's source.
 
 Remixing is enabled by default. An explicit `remixPolicy` must permit remixing
-and must not set `sourceInspection: "no"`. Omit optional settings when defaults
+and must not set `sourceInspection: "no"`. A Block's code is private to its creator: no one else views or downloads it,
+and others change it only by describing changes to StillMade's AI builder.
+Omit optional settings when defaults
 are sufficient. The host creates the new identity, preserves the parent digest,
 source and notices, and presents the ordinary builder. Creators need no extra
 StillMade instructions. Project Edit retains compatible inputs and saved state;
@@ -10409,8 +10860,9 @@ remixable merely by adding metadata: they need an independent SDK implementation
 ### In StillMade
 
 Choose **Remix Block** on an exact public Block version, or **Remix this version**
-in Marketplace. Sign in, review its source, license and declared permissions,
-then confirm **Remix Block**. StillMade saves an account draft and opens Create.
+in Marketplace. Sign in, review its license and declared permissions, then
+confirm **Remix Block**. The code is never shown or downloadable; describe the
+change you want and StillMade's AI builder makes it. StillMade saves an account draft and opens Create.
 Nothing is installed, published, executed or charged by creating the draft.
 AI refinement edits the implementation, controls and fixtures while the host
 retains and restores immutable source evidence and ancestry. Evidence is not
@@ -10418,7 +10870,10 @@ charged against the editable-source prompt limit; the package size limit still
 applies. The resulting local Block receives the same admission checks as a
 portable artifact.
 The Versions tab shows ancestry and retained notices. Publishing the edited
-Block requires the normal validation, visibility choice and rights confirmation.
+Block requires the normal validation and rights confirmation. A remix of someone
+else's Block is released as a Block owned by the original creator, who keeps its
+code and earns from it; the remixer is credited and can use it right away. A
+remix is always available by link, never private.
 Public Block pages link to paginated newest and top remixes of that exact version.
 Top uses qualified production account counts for a 30-day window, hidden below
 ten accounts and rounded down to tens. Both views fall back to newest when
@@ -10537,13 +10992,13 @@ host-coupled workspaces retain their existing restrictions.
 - No payments, ancestor revenue allocation or provider dispatch during remix.
 
 
-### Public source inspection
+### Code stays private
 
-Source inspection settings on existing releases remain subject to their original
-access controls. For new Block admission, `sourceInspection: "no"` is rejected.
-Use `yes`, a supported `license-controlled` setting, or omit the field. Account
-and team visibility still determine who may retrieve a private package; remix
-support does not make private source public.
+A Block's code is private to its creator. Nobody else can view or download it:
+public pages, Marketplace and remixes never show it, and the source download
+works only for its creator and StillMade admins. An older `sourceInspection: "no"`
+still keeps that Block's releases private and its remix action off. Account and team visibility still determine who may use a
+private package.
 
 A source-access choice cannot replace legal evidence or revoke upstream rights.
 Existing immutable releases keep their established pins and access. Newly finished
@@ -10552,7 +11007,7 @@ versions must pass the required remix, license and normal admission checks.
 
 ## Portable packages and repository adaptation
 
-Every finished Block must support automatic remixing through the standard SDK contract. Include complete editable runtime source/configuration, typed inputs/outputs, UI controls, fixtures, and a supported permissive manifest.license with its complete real copyright/license notice in manifest.provenance.notice (or verified portable evidence). Do not disable remixing or source inspection. No custom remix endpoint or host callback is needed. Preserve inherited source, notices and lineage. Never invent ownership, copyright holders or permission, or apply a new license to unresolved third-party source; return unsupported with a clear licensing reason instead. The shared SDK admission validator enforces this requirement.
+Every finished Block must support automatic remixing through the standard SDK contract. Include complete editable runtime source/configuration, typed inputs/outputs, UI controls, fixtures, and a supported permissive manifest.license with its complete real copyright/license notice in manifest.provenance.notice (or verified portable evidence). Do not disable remixing. The code stays private to its creator; others remix only through StillMade’s AI builder. No custom remix endpoint or host callback is needed. Preserve inherited source, notices and lineage. Never invent ownership, copyright holders or permission, or apply a new license to unresolved third-party source; return unsupported with a clear licensing reason instead. The shared SDK admission validator enforces this requirement.
 ### Understand StillMade and its Block ecosystem
 
 StillMade AI is an AI-assisted platform where people make things by using and
@@ -10770,9 +11225,10 @@ of the SDK URL the user supplied, not a guessed production hostname or localhost
 - Search `/api/public-listings/discover?kind=block&search=<encoded-query>` for
   Blocks, or use `kind=type` for Project Types. Follow `nextCursor` with `after`
   when more results are relevant; a single page is not the complete catalog.
-- Use returned listing identities and versions to inspect
-  `/api/public-listings/<kind>/<id>/<version>/source.json` where source inspection
-  is permitted. Read the real manifest and any declared dependency packages.
+- Use returned listing identities and versions to read
+  `/api/public-listings/<kind>/<id>/<version>/metadata.json`: its name, description
+  and typed inputs and outputs. A Block's code is private to its creator, so build
+  on what it takes and makes, never on its source.
 - In an offline SDK checkout, `packages/block-platform/catalog.js` provides bundled
   first-party examples. It is a snapshot, not the complete live Marketplace.
 
@@ -11268,7 +11724,7 @@ Capability Blocks (`image.generate`, `video.generate`, `audio.music`, `audio.sfx
 | `seedance-2.0-fast` | Seedance 2.0 Fast | 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 | 480p, 720p | auto, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16 | yes | yes | yes |
 | `seedance-2.0-mini` | Seedance 2.0 Mini | 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 | 480p, 720p | auto, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16 | yes | yes | yes |
 | `kling-v3-turbo` | Kling 3.0 Turbo | 5, 10 | model default | 16:9, 9:16, 1:1 | yes | no | no |
-| `wan-2.6-flash` | Wan 2.6 Flash | 3, 4, 5 | model default | 16:9, 9:16, 1:1 | yes | no | no |
+| `wan-2.6-flash` | Wan 2.6 Flash | 3, 4, 5 | model default | 16:9, 9:16, 1:1 | required | no | no |
 | `veo-3.1-lite` | Veo 3.1 Lite | 4, 6, 8 | 720p, 1080p | 16:9, 9:16 | yes | yes | yes |
 | `vidu-q3-turbo` | Vidu Q3 Turbo | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 | model default | model default | yes | yes | yes |
 | `wan-2.7` | Wan 2.7 | 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 | 720p, 1080p | model default | required | yes | no |
@@ -11410,6 +11866,8 @@ The latest version of each Block bundled with the SDK, generated from the packag
 
 | Block | Name | Kind | Inputs | Outputs |
 | --- | --- | --- | --- | --- |
+| `sm.ai-decide` 1.0.0 | AI decide | task | `data` text (external_data) · primary; `rules` text (decision_rules) | `decision` object (ai_decision) · primary |
+| `sm.ai-write` 1.0.0 | AI write | task | `data` text (external_data) · primary; `instructions` text (writing_instructions) | `text` text (written_message) · primary |
 | `sm.animated-scene` 2.3.8 | Animated Scene | workspace | `animation` scene-document (animated_scene_document) · project context only · primary; `shotPlan` shot-plan (production_shot_plan) · project context only; `updatedAnimation` scene-document (animated_scene_document); `commit` boolean (apply_changes); `generatedImage` image (image); `targetShotId` text (target_shot); `targetLayerId` text (target_layer); `attachGeneratedImage` boolean (attach_image); `action` text (animated_scene_action); `versions` metadata[] (revision_history) · project context only; `presence` metadata[] (collaborator_presence); `assets` asset[] (project_media) · project context only | `animation` scene-document (animated_scene_document) · primary; `edit` workspace-edit (workspace_edit); `qualityAction` approval (portable_media_action); `renderAction` approval (portable_media_action); `qualityReport` metadata (quality_report); `editorTimeline` timeline (editor_handoff); `revision` metadata (revision_event) |
 | `sm.animated-scene-assistant` 1.0.0 | Plan Animated Scene | task | `animation` scene-document · project context only; `request` text · primary | `edit` workspace-edit · primary |
 | `sm.blueprint` 2.1.9 | Blueprint | workspace | `blueprint` bible (production_blueprint) · project context only · primary; `updatedBlueprint` bible (production_blueprint); `commit` boolean (apply_changes); `assistantEdit` workspace-edit (workspace_edit); `versions` metadata[] (revision_history) · project context only; `presence` metadata[] (collaborator_presence); `assets` asset[] (project_media) · project context only | `blueprint` bible (production_blueprint) · primary; `edit` workspace-edit (workspace_edit); `shotPlan` shot-plan (shot_plan_handoff); `revision` metadata (revision_event) |
@@ -11419,6 +11877,9 @@ The latest version of each Block bundled with the SDK, generated from the packag
 | `sm.character` 2.0.1 | Character reference | workspace | `input` text (character_description) · primary; `name` text (character_name); `role` text (character_role); `appearance` text (character_appearance); `personality` text (character_personality) | `output` character (character_reference) · primary |
 | `sm.chat` 2.0.3 | Production chat | workspace | `brief` brief (production_brief) · primary | `script` script (narration_script) · primary |
 | `sm.compare` 2.0.2 | Compare assets | workspace | `imageA` image (comparison_image_a) · primary; `imageB` image (comparison_image_b); `selection` text (comparison_selected_image); `position` integer (comparison_split_position) | `output` image (selected_comparison_image) · primary |
+| `sm.connect-app` 1.0.0 | Connect an app | task | `app` text (connected_app) · primary | `result` object (external_data) · primary |
+| `sm.contact-fields` 1.0.0 | Contact fields | task | `record` object (external_data) · primary | `email` text (contact_email) · primary; `first_name` text (contact_first_name); `last_name` text (contact_last_name); `full_name` text (contact_full_name); `phone` text (contact_phone); `company` text (contact_company); `city` text (contact_city); `other_answers` text (contact_other_answers) |
+| `sm.continue-if` 1.0.0 | Continue only if | task | `decision` object (ai_decision) · primary; `item` object (external_data); `minimum_score` integer (minimum_score) | `item` object (external_data) · primary |
 | `sm.describe-media` 2.0.1 | Describe media | task | `image` image (source_image) · primary | `description` text (visual_description) · primary |
 | `sm.edit-assistant` 2.0.2 | Edit Assistant | task | `timeline` timeline (timeline) · project context only · primary; `selection` timeline-range (timeline_range); `request` text (edit_request) | `edit` timeline-edit (timeline_edit_proposal) · primary |
 | `sm.editor` 2.2.12 | Editor | workspace | `editor` timeline (editor_timeline) · project context only · primary; `assets` asset[] (legacy.asset-list.assets) · project context only; `updatedEditor` timeline (legacy.timeline.updatededitor); `commit` boolean (legacy.boolean.commit); `action` text (legacy.text.action); `renderFps` integer (legacy.integer.renderfps); `renderResolution` integer (legacy.integer.renderresolution); `renderQuality` text (legacy.text.renderquality) | `editor` timeline (editor_timeline) · primary; `edit` workspace-edit (legacy.workspace-edit.edit); `mediaAction` approval (portable_media_action) |
@@ -11426,13 +11887,15 @@ The latest version of each Block bundled with the SDK, generated from the packag
 | `sm.export-timeline` 2.0.0 | Export timeline | editor-extension | `timeline` timeline · project context only · primary; `assets` asset[] · project context only; `blueprint` bible · project context only; `shotPlan` shot-plan · project context only; `metadata` metadata · project context only; `title` text; `format` text | `download` file-bundle · primary |
 | `sm.export-video` 2.0.0 | Export video | task | `input` timeline (timeline) · primary; `renderFps` text (render_fps); `renderResolution` text (render_resolution); `renderQuality` text (render_quality); `projectTimeline` timeline (timeline) · project context only | `mediaAction` approval (portable_media_action); `output` video (rendered_video) |
 | `sm.final-edit` 2.0.2 | AI Final Edit | task | `timeline` timeline (timeline) · project context only · primary; `direction` text (edit_direction) | `edit` timeline-edit (timeline_edit_proposal) · primary |
-| `sm.generate-image` 2.0.0 | Generate image | task | `input` text · primary | `output` image · primary |
+| `sm.generate-image` 2.1.0 | Generate image | task | `input` text · primary; `photos` image[] (reference_image) | `output` image · primary |
 | `sm.generate-video` 2.0.1 | Generate video | task | `prompt` brief (video_generation_brief) · primary | `video` video (generated_video) · primary |
 | `sm.grade` 2.0.2 | Color grade | editor-extension | `timeline` timeline (editor_timeline) · project context only · primary; `clipIds` text[] (timeline_clip_ids); `look` text (color_grade_look); `adjustments` json (color_grade_adjustments) | `edit` timeline-edit (timeline_edit) · primary |
 | `sm.image-editor` 2.0.1 | Image editor | workspace | `input` image (source_image) · primary; `brightness` number (brightness_adjustment); `contrast` number (contrast_adjustment) | `output` image (processed_image) · primary |
 | `sm.import-media` 2.0.2 | Import media | task | `files` asset[] (legacy.asset-list.files) · primary; `include` text (legacy.text.include); `duplicates` text (legacy.text.duplicates) | `assets` asset[] (legacy.asset-list.assets) · primary |
 | `sm.location` 2.0.1 | Location reference | workspace | `input` text (location_description) · primary; `name` text (location_name); `visualDetails` text (location_visual_details); `timeOfDay` text (location_time); `atmosphere` text (location_atmosphere) | `output` location (location_reference) · primary |
+| `sm.meta-creative` 1.0.0 | Meta ad creative | task | `upload` object (external_data) · primary; `message` text (ad_primary_text); `website_url` text (ad_destination_url); `page_id` text (facebook_page_id); `call_to_action` text (ad_call_to_action) | `creative` object (meta_ad_creative) · primary |
 | `sm.motion-graphics` 2.0.0 | Motion graphics | editor-extension | `timeline` timeline (timeline) · primary; `projectTimeline` timeline (timeline) · project context only; `plan` json (motion_graphics_plan) | `timeline` timeline (timeline) · primary; `edit` workspace-edit (editor_workspace_edit) |
+| `sm.new-items` 1.0.0 | Only new items | task | `items` object (external_data) · primary; `id_field` text (item_id_field) | `item` object (external_data) · primary; `waiting` integer (pending_item_count) |
 | `sm.panel-strip` 2.3.7 | Image Panels | workspace | `panels` panel-document (image_panel_document) · project context only · primary; `transcript` transcript (timed_transcript) · project context only; `script` script (narration_script) · project context only; `blueprint` bible (production_blueprint) · project context only; `updatedPanels` panel-document (image_panel_document); `commit` boolean (apply_changes); `generatedImage` image (image); `targetPanelId` text (panel_id); `attachGeneratedImage` boolean (boolean); `action` text (host_action); `stockQuery` text (stock_query); `generatedImages` image[] (image_list) | `panels` panel-document (image_panel_document) · primary; `edit` workspace-edit (workspace_edit); `stockAction` approval (portable_media_action); `qualityAction` approval (portable_media_action); `renderAction` approval (portable_media_action); `stockAsset` asset (licensed_asset); `stockImage` image (licensed_stock_image); `qualityReport` metadata (quality_report); `generationPlan` metadata (generation_plan); `generateAction` approval (portable_media_action); `generatedImage` image (generated_image); `batchGenerateAction` approval (portable_media_action); `generatedImages` image[] (generated_image_list) |
 | `sm.pipeline` 2.2.5 | Canvas | workspace | `canvas` pipeline (canvas_document) · project context only · primary; `assets` asset[] (project_assets) · project context only; `versions` metadata[] (asset_versions) · project context only; `updatedCanvas` pipeline (canvas_document); `commit` boolean (canvas_commit_intent); `generatedImage` image (generated_image_version); `addGeneratedImage` boolean (attach_generated_image); `generatedImageTitle` text (generated_image_title); `generatedVideo` video (generated_video_version); `addGeneratedVideo` boolean (attach_generated_video); `generatedVideoTitle` text (generated_video_title); `generatedAudio` audio (generated_audio_version); `addGeneratedAudio` boolean (attach_generated_audio); `generatedAudioTitle` text (generated_audio_title); `connectionProposal` json (context_connection_proposal); `applyContextConnections` boolean (context_connection_intent) | `canvas` pipeline (canvas_document) · primary; `edit` workspace-edit (canvas_edit_proposal) |
 | `sm.quality-audit` 1.0.2 | Quality review plan | task | `assets` asset[] (saved_asset_versions) · project context only · primary | `plan` metadata (visual_quality_review_plan) · primary |
@@ -11448,14 +11911,16 @@ The latest version of each Block bundled with the SDK, generated from the packag
 | `sm.transcribe` 2.0.1 | Transcription | task | `audio` audio (source_audio) · primary; `language` text (transcription_language) | `transcript` transcript (transcript_text) · primary |
 | `sm.transition` 2.0.2 | Transition | editor-extension | `timeline` timeline (editor_timeline) · project context only · primary; `clipIds` text[] (timeline_clip_ids); `transition` text (timeline_transition_type); `duration` number (timeline_transition_duration); `soundOn` boolean (timeline_transition_sound_enabled); `soundId` text (timeline_transition_sound_id) | `edit` timeline-edit (timeline_edit) · primary |
 | `sm.video-assets` 2.1.4 | Video Assets | workspace | `assets` asset[] (media_collection) · project context only · primary; `versions` metadata[] (media_version_history) · project context only; `incoming` asset[] (media_collection); `kind` text (media_filter); `selectedIds` text (media_selection); `selectedVersions` text (media_version_selection) | `output` asset[] (production_media) · primary |
-| `sm.voiceover` 2.1.4 | Voiceover | workspace | `input` script (narration_script) · primary; `take` audio (narration_audio); `library` asset[] (project_media) · project context only; `timing` transcript (timed_transcript) · project context only | `output` audio (narration_audio) · primary |
+| `sm.voiceover` 2.1.6 | Voiceover | workspace | `input` script (narration_script) · primary; `take` audio (narration_audio); `library` asset[] (project_media) · project context only; `timing` transcript (timed_transcript) · project context only | `output` audio (narration_audio) · primary |
+| `sm.when` 1.0.0 | When | task | `event` object (workflow_event) | `trigger` object (automation_trigger) · primary |
 | `sm.whiteboard-assistant` 1.0.0 | Build Whiteboard | task | `board` board-document · project context only; `request` text · primary | `edit` workspace-edit · primary |
+| `sm.write-summary` 1.0.0 | Write summary | task | `data` text (external_data) · primary | `summary` text (summary_report) · primary |
 | `sm.youtube` 2.0.0 | YouTube publication | task | `video` video (finished_video) · primary; `title` text; `description` text; `tags` text; `visibility` text; `publishAt` text; `madeForKids` boolean; `aiGenerated` boolean | `uploadAction` approval (portable_media_action); `publication` json (youtube_publication) |
-| `stillmade.occasion-story` 1.0.1 | Occasion Story | task | `assets` asset[] (legacy.asset-list.assets) · primary; `occasion` text (stillmade.occasion_story.occasion); `title` text (stillmade.occasion_story.title); `ending` text (stillmade.occasion_story.ending); `notes` text (stillmade.occasion_story.notes); `selections` text (stillmade.occasion_story.selections); `music` audio[] (stillmade.occasion_story.music); `musicVolume` number (stillmade.occasion_story.musicvolume); `muteVideoAudio` boolean (stillmade.occasion_story.mutevideoaudio); `aspect` text (stillmade.occasion_story.aspect); `disclosure` text (stillmade.occasion_story.disclosure); `rightsConfirmed` boolean (stillmade.occasion_story.rightsconfirmed) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.occasion_story.review) |
-| `stillmade.photo-reel-composer` 1.0.0 | Photo Reel Composer | task | `assets` asset[] (legacy.asset-list.assets) · primary; `purpose` text (stillmade.photo_reel.purpose); `title` text (stillmade.photo_reel.title); `captions` text (stillmade.photo_reel.captions); `cta` text (stillmade.photo_reel.cta); `contact` text (stillmade.photo_reel.contact); `demoDisclosure` text (stillmade.photo_reel.demodisclosure); `duration` number (stillmade.photo_reel.duration); `aspect` text (stillmade.photo_reel.aspect); `logo` asset[] (stillmade.photo_reel.logo); `music` asset[] (stillmade.photo_reel.music); `rightsConfirmed` boolean (stillmade.photo_reel.rightsconfirmed) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.photo_reel.review); `provenance` json (stillmade.photo_reel.provenance) |
+| `stillmade.occasion-story` 1.0.2 | Occasion Story | task | `assets` asset[] (legacy.asset-list.assets) · primary; `occasion` text (stillmade.occasion_story.occasion); `title` text (stillmade.occasion_story.title); `ending` text (stillmade.occasion_story.ending); `notes` text (stillmade.occasion_story.notes); `selections` text (stillmade.occasion_story.selections); `music` audio[] (stillmade.occasion_story.music); `musicVolume` number (stillmade.occasion_story.musicvolume); `muteVideoAudio` boolean (stillmade.occasion_story.mutevideoaudio); `aspect` text (stillmade.occasion_story.aspect); `disclosure` text (stillmade.occasion_story.disclosure) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.occasion_story.review) |
+| `stillmade.photo-reel-composer` 1.0.1 | Photo Reel Composer | task | `assets` asset[] (legacy.asset-list.assets) · primary; `purpose` text (stillmade.photo_reel.purpose); `title` text (stillmade.photo_reel.title); `captions` text (stillmade.photo_reel.captions); `cta` text (stillmade.photo_reel.cta); `contact` text (stillmade.photo_reel.contact); `demoDisclosure` text (stillmade.photo_reel.demodisclosure); `duration` number (stillmade.photo_reel.duration); `aspect` text (stillmade.photo_reel.aspect); `logo` asset[] (stillmade.photo_reel.logo); `music` asset[] (stillmade.photo_reel.music) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.photo_reel.review); `provenance` json (stillmade.photo_reel.provenance) |
 | `stillmade.product-ad-variants` 1.0.0 | Product Ad Variants | task | `timeline` timeline (legacy.timeline.updatededitor) · primary; `hookA` text (stillmade.product_ad_variants.hooka); `hookB` text (stillmade.product_ad_variants.hookb); `hookC` text (stillmade.product_ad_variants.hookc); `openingA` number (stillmade.product_ad_variants.openinga); `openingB` number (stillmade.product_ad_variants.openingb); `openingC` number (stillmade.product_ad_variants.openingc); `openingDuration` number (stillmade.product_ad_variants.openingduration); `copyApproved` boolean (stillmade.product_ad_variants.copyapproved) | `variantA` timeline (legacy.timeline.updatededitor) · primary; `variantB` timeline (legacy.timeline.updatededitor); `variantC` timeline (legacy.timeline.updatededitor); `review` json (stillmade.product_ad_variants.review) |
-| `stillmade.release-visuals` 1.0.1 | Release Visuals | task | `assets` asset[] (legacy.asset-list.assets) · primary; `purpose` text (stillmade.release_visuals.purpose); `title` text (stillmade.release_visuals.title); `artist` text (stillmade.release_visuals.artist); `cta` text (stillmade.release_visuals.cta); `duration` number (stillmade.release_visuals.duration); `songVolume` number (stillmade.release_visuals.songvolume); `offset` number (stillmade.release_visuals.offset); `lyrics` text (stillmade.release_visuals.lyrics); `aspect` text (stillmade.release_visuals.aspect); `disclosure` text (stillmade.release_visuals.disclosure); `rightsConfirmed` boolean (stillmade.release_visuals.rightsconfirmed) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.release_visuals.review) |
-| `stillmade.short-form-finish` 1.0.2 | Short-form Finish | task | `assets` video[] (legacy.asset-list.assets) · primary; `music` audio[] (legacy.asset-list.assets); `audioMode` text (stillmade.short_form.audiomode); `speechVolume` number (stillmade.short_form.speechvolume); `purpose` text (stillmade.short_form.purpose); `cuts` text (stillmade.short_form.cuts); `subtitles` text (stillmade.short_form.subtitles); `title` text (stillmade.short_form.title); `byline` text (stillmade.short_form.byline); `cta` text (stillmade.short_form.cta); `disclosure` text (stillmade.short_form.disclosure); `captionStyle` text (stillmade.short_form.captionstyle); `aspect` text (stillmade.short_form.aspect); `fit` text (stillmade.short_form.fit); `cropX` number (stillmade.short_form.cropx); `rightsConfirmed` boolean (stillmade.short_form.rightsconfirmed) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.short_form.review) |
+| `stillmade.release-visuals` 1.0.2 | Release Visuals | task | `assets` asset[] (legacy.asset-list.assets) · primary; `purpose` text (stillmade.release_visuals.purpose); `title` text (stillmade.release_visuals.title); `artist` text (stillmade.release_visuals.artist); `cta` text (stillmade.release_visuals.cta); `duration` number (stillmade.release_visuals.duration); `songVolume` number (stillmade.release_visuals.songvolume); `offset` number (stillmade.release_visuals.offset); `lyrics` text (stillmade.release_visuals.lyrics); `aspect` text (stillmade.release_visuals.aspect); `disclosure` text (stillmade.release_visuals.disclosure) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.release_visuals.review) |
+| `stillmade.short-form-finish` 1.0.3 | Short-form Finish | task | `assets` video[] (legacy.asset-list.assets) · primary; `music` audio[] (legacy.asset-list.assets); `audioMode` text (stillmade.short_form.audiomode); `speechVolume` number (stillmade.short_form.speechvolume); `purpose` text (stillmade.short_form.purpose); `cuts` text (stillmade.short_form.cuts); `subtitles` text (stillmade.short_form.subtitles); `title` text (stillmade.short_form.title); `byline` text (stillmade.short_form.byline); `cta` text (stillmade.short_form.cta); `disclosure` text (stillmade.short_form.disclosure); `captionStyle` text (stillmade.short_form.captionstyle); `aspect` text (stillmade.short_form.aspect); `fit` text (stillmade.short_form.fit); `cropX` number (stillmade.short_form.cropx) | `timeline` timeline (legacy.timeline.updatededitor) · primary; `review` json (stillmade.short_form.review) |
 
 ## Custom view rules