Class ScriptApi

Cancel every running (suspended) script the acting actor owns — the barge-in path. The actor is derived from execution context (never a parameter); each coroutine stops with the typed reason, aborting its in-flight engaged step (its effect never lands — partial matter standing, no rollback). Wired into the stop/cancel verb.

Capture a faithful manual build as the builder's learned recipe: mint the can-make deed and transcribe + bank the personal recipe-script — the same act (learning is getting the script). Called at the strain step's engaged completion, which the scheduler runs inside an authorless runRoot('completion') frame — so the builder (captured from the live command frame at dispatch, then threaded here) is stamped as that frame's acting author via ExecutionContextApi.tagActingAuthor. That stamp is the framework seam a controller can't reach (frame mutators are framework-only); the downstream noteMade / Transcriber.transcribe read it back through getActingAuthor. Returns the banked script path, or null when nothing was captured (already learned, or no resolvable owner).

Serialize a Script AST back to canonical language source. The round-trip property is parse(format(parse(t))) ≡ parse(t). This is the substrate demonstration capture (P8) emits real source through — the recorded artifact is language source, not an opaque trace.

Invalidate the resolve cache for path (the HotReloadApi.reload analog) so the next invocation re-parses the stored source — a CMS edit or a re-record reaches the next run without a restart.

Invoke a named session script (a def'd recipe) with positional args, binding its params — the make <recipe> path. The acting actor is derived from context; the script runs paced by the coroutine (engaged steps trickle out). Resolves true if a script of that name was found and started, false otherwise (the caller declines). The authored-content recipe-script source (loaded from the path-addressed store) lands in P7; v1 invokes session defs.

Resolve and run the stored script at path (re-resolved per invocation, cached until goLive). Runs as the acting actor, paced by the coroutine. Resolves true if a script was found at the path, false otherwise.

Parse and run raw script text as the acting actor. Convenience over runAst for programmatic / REPL callers; production prompt dispatch goes through the parser → runAst path.

Run an already-parsed Script as the acting actor. Entry point from the command dispatcher's parseResult.script branch — the script parser hands the dispatcher the AST, the dispatcher hands it here. Walks the script through the interpreter, dispatching each command over the bus. Resolves when the script completes (or suspends into a detached background coroutine — P5).

Save a script's source to the path-addressed store, keyed on path (owner/scope encoded in the path). Mutation is access-gated on the covering zone (AccessApi), the owner is set from the acting author, authorship is appended to the provenance ledger keyed on the path, and the resolve cache is invalidated (go-live). The acting author is derived from context, never a parameter.