concept G22LeftArrowScript > G22Text {
  // the latest code that has been cleared to auto-run (if any)
  settableWithVar ClearForAutoRun<S> clearedForAutoRun;

  // auto-run when project is opened
  settableWithVar bool runOnProjectOpen;
  
  // only when runOnProjectOpen is seT:
  // when to run in sequence (sorted with alphanumIC)
  settableWithVar S runOrder;
  
  // run stats
  long runCount;
  
  // info about last result (or error) of script run by mode
  Map<G22ScriptMode, WithTimestamp<PersistableOKOrError<G22TypeDesc>>> lastResultByMode;
  
  // is there a newer version of this script?
  new Ref<G22LeftArrowScript> supercededBy;
  
  // Put meta-functions here (e.g. for improving an IDE showing
  // this script)
  settableWithVar S metaCode;
  
  void _doneLoading2 :: after {
    //print("_doneLoading " + this);
    cMigrateField(this, "code", "text");
  }
  
  toString {
    if (empty(description)) 
      ret myType() + " " + id;
    else
      ret "Script " + id + ": " + description;
  }
  
  bool isSavedDistinctFromAutoRunVersion() { ret isSaved() && !eq(text, codeForAutoRun()); }
  bool isClearForAutoRun() { ret clearedForAutoRun != null; }
  
  S codeForAutoRun() { ret getVar(clearedForAutoRun()); }
  
  // return code clear for auto run if available
  // otherwise returns saved code if available
  // in all other cases returns null
  // (never returns text being edited)
  S safestCode() { ret or(codeForAutoRun(), stableText()); }
  
  void clearForAutoRun {
    if (!isSaved()) ret;
    S text = text();
    saveFieldToHistory("Auto-runnable code", text);
    clearedForAutoRun(new ClearForAutoRun(text));
  }
  
  void forgetAutoRunCode {
    if (!isClearForAutoRun()) ret;
    saveFieldToHistory("Auto-runnable code", null);
    clearedForAutoRun(null);
    compileResultForAutoRun = null;
  }
  
  void forgetCompileResults {
    compileResultForAutoRun = compileResultForSaved = null;
  }

  GazelleV_LeftArrowScriptParser makeParser() {
    ret g22utils().leftArrowParser()
      .sourceInfo(this);
  }
  
  LASCompileResult newCompileResult() { ret new LASCompileResult; }
  
  LASCompileResult returnOrCompile(LASCompileResult lastCompileResult, S code) {
    if (g22utils().compileResultValid(lastCompileResult, code))
      ret lastCompileResult;
    var cr = newCompileResult();
    cr.script(code);
    var parser = makeParser();
    cr.parser(parser);
    cr.compile();
    ret cr;
  }
  
  transient LASCompileResult compileResultForAutoRun;
  LASCompileResult compileForAutoRun() {
    S code = codeForAutoRun();
    if (code == null) null;
    var cr = returnOrCompile(compileResultForAutoRun, code);
    ret compileResultForAutoRun = cr;
  }
  
  transient LASCompileResult compileResultForSaved;
  LASCompileResult compileSaved() {
    S code = stableText();
    if (code == null) null;
    var cr = returnOrCompile(compileResultForSaved, code);
    ret compileResultForSaved = cr;
  }
  
  transient LASCompileResult compileResultForEditing;
  LASCompileResult compileEditing() {
    S code = editingText();
    if (code == null) null;
    var cr = returnOrCompile(compileResultForEditing, code);
    ret compileResultForEditing = cr;
  }
  
  LASCompileResult safestCompileResult() {
    try object compileForAutoRun();
    ret compileSaved();
  }
  
  LASCompileResult latestCompileResult() {
    try object compileEditing();
    try object compileSaved();
    ret compileForAutoRun();
  }
  
  LASCompileResult latestRunnableCompileResult() {
    var cr = compileEditing();
    if (cr != null && cr.runnable()) ret cr;
    cr = compileSaved();
    if (cr != null && cr.runnable()) ret cr;
    cr = compileForAutoRun();
    if (cr != null && cr.runnable()) ret cr;
    null;
  }
  
  O evaluateWithoutTimeout() {
    var cr = safestCompileResult();
    if (cr == null)
      fail("Not saved: " + this);
      
    temp g22utils().enter(); // enter module
    ret cr.parsedScriptMandatory()!;
  }
  
  O evaluateAutoRunWithoutTimeout() {
    var cr = compileForAutoRun();
    if (cr == null)
      fail("Not cleared for auto-run: " + this);
      
    temp g22utils().enter(); // enter module
    ret cr.parsedScriptMandatory()!;
  }
  
  S renderRunOnProjectOpenStatus() {
    ret runOnProjectOpen
      ? "Yes" + appendBracketed(appendPrefixIfNempty("prio ", runOrder))
      : null;
  }
  
  Set<S> allTexts() {
    ret addAndReturnCollection(super.allTexts(), codeForAutoRun());
  }
}