ojs chunk option include not working

[am-lh]

Bug description

Hi,
I am including a observable plot in a html document. I am used to set in the yaml as:

---
format:
  html:
    code-fold: true
execute:
  eval: true
  echo: true
  message: false
  warning: false
  output: true
  include: false
---

and selectively set the include option to true where I need it.
However, doing so, the ojs chunks does not appear when adding the //|include option, the same working perfectly when yaml include option set to true. I have also tried the {ojs, include=TRUE} like mermaid syntax, and all combination in between them.
Seems that the yaml option overwrite the local one?

Steps to reproduce

```{r}
library(palmerpenguins)
ojs_define(data = penguins)
```

```{ojs}
//| panel: sidebar
//| include: true

viewof bill_length_min = Inputs.range(
  [32, 50], 
  {value: 32, step: 1, label: "Bill length (min):"}
)

viewof islands = Inputs.checkbox(
  ["Torgersen", "Biscoe", "Dream"], 
  { value: ["Torgersen", "Biscoe", "Dream"], 
    label: "Islands:"
  }
)

```

::: {.panel-tabset}

## Graph

```{ojs}
//| include: true
Plot.plot({
  facet: {data: filtered, 
          x: "sex",
          y: "island"},
  color: { legend: true },
  marks: [
    Plot.frame({ strokeOpacity: 0.1 }),
    Plot.dot(filtered, {
      x: "body_mass_g",
      y: "bill_length_mm",
      stroke: "species",
      tip: true
    })
  ]
})

```

## Data
```{ojs}
//| include: true

Inputs.table(filtered, {  columns: [
    "body_mass_g", "flipper_length_mm", "species","bill_length_mm"
  ]})

```
:::

```{ojs}

filtered = transpose(data).filter(function(penguin) {
  return bill_length_min < penguin.bill_length_mm &&
         islands.includes(penguin.island);
})

```

Expected behavior

The ojs chunk should appear in the rendered doc when yaml option is false and chunk option are true

Actual behavior

the ojs chunk does not appear, only the two empty tabsets

Your environment

My settings:

 version  R version 4.3.0 (2023-04-21 ucrt)
 os       Windows 10 x64 (build 19045)
 system   x86_64, mingw32
 ui       RStudio
 language EN
 collate  French_France.utf8
 ctype    French_France.utf8
 tz       Europe/Paris
 date     2023-06-21
 rstudio  2023.06.0+421 Mountain Hydrangea (desktop)
 pandoc   3.1.1 @ C:/Program Files/RStudio/resources/app/bin/quarto/bin/tools/ (via rmarkdown)

quarto : "1.3.361"

Quarto check output

[>] Checking versions of quarto binary dependencies...
      Pandoc version 3.1.1: OK
      Dart Sass version 1.55.0: OK
[>] Checking versions of quarto dependencies......OK
[>] Checking Quarto installation......OK
      Version: 1.3.361
      Path: C:\Users\lehuen201\AppData\Local\Programs\Quarto\bin
      CodePage: 1252

[>] Checking basic markdown render....OK

[>] Checking Python 3 installation....OK
      Version: 3.11.4
      Path: C:/Python311/python.exe
      Jupyter: (None)

      Jupyter is not available in this Python installation.
      Install with py -m pip install jupyter

[>] Checking R installation...........OK
      Version: 4.3.0
      Path: C:/Users/lehuen201/AppData/Local/Programs/R/R-4.3.0
      LibPaths:
        - C:/Users/lehuen201/AppData/Local/Programs/R/R-4.3.0/library
      knitr: 1.43
      rmarkdown: 2.22

[>] Checking Knitr engine render......OK

[am-lh]

In addition, this problem seems to mess with a table containing rmarkdown equation: with yaml include: false, I have the table ok but not the observable plot, with include: true, observable is ok, but the equation is not parsed.

```{r}
#| label: tbl-eq_cases
#| results: asis
#| include: true
#| tbl-cap: "an equation table"

library(kableExtra)
my_equations<-data.frame(
  num=c("","1","2"),
  text=c(
    "**Equation 3 Cases (q)**",
"$$
Q_{fluff}\\left(t_0\\right)=Q_{inf}.\\left(1-e^{-a_{bio}.BioFact.t}\\right)+\\varepsilon
$$",
"$$
Q_{fluff}\\left(t_0\\right)=\\left(a_{QBio}.BioFact+b_{QBio}\\right).\\ \\left(a_{QSed}.SedFact+b_{QSed}\\right)
$$"))

tab <- kable(my_equations,  
             col.names = NULL, format = "markdown" #,
           ) %>%
    kable_styling(bootstrap_options = c("striped", "condensed"),
                  full_width = F) ; tab
```

[cscheid]

@cderv Could this be a knitr or rmd.R bug? Here's what's happening. If execute: false is present at the document level, then knitr doesn't include the OJS cells, even if they have include: true in them. The keep-md output looks like this:

---
format:
  html:
    code-fold: true
keep-md: true
execute:
  eval: true
  echo: true
  message: false
  warning: false
  output: true
  include: false
---







::: {.panel-tabset}

## Graph





## Data



:::

Even though the OJS cells have //| include: true in them.

[cderv]

If execute: false is present at the document level,

You mean include: false at top level right ?

Something is definitely not right in how ojs cell is handled. It seems knitr is not aware of the internal ojs cell option and this is why global default is not changed. I'll investigate what is happening.

Just to confirm: Are OJS cells handles after computation evaluation by quarto ? meaning after knitr ? What should be the output of the knitr step ? Should the //| options still be in the .md output or were they process before by Quarto ?

[cscheid]

Just to confirm: Are OJS cells handles after computation evaluation by quarto ? meaning after knitr ? What should be the output of the knitr step ? Should the //| options still be in the .md output or were they process before by Quarto ?

Yes, they're handled between engine execution and pandoc.

The problem here is that knitr would need to be able to recognize that an OJS code chunk has an include: true value, and then just forward it unchanged. I believe we have an "identity" hook for OJS blocks, but it doesn't look to be getting called here.

[cderv]

I believe we have an "identity" hook for OJS blocks, but it doesn't look to be getting called here.

Yes we have that but with current implementation it is not just a hook but an engine which is supposed to output the same as entry. However, I believe it will be ignored because include: false is passed globally, and so knitr will not include the engine results unless include: true at the cell option level is found for that engine. This is the same for all kind of knitr engines

I do believe knitr can learn about OJS cell options - not an issue to add that to me in the parsing code.

However, I'll see if I can come up with another hook-type that would not be impacted by cell options like include.

But it is at the basis of knitr that engines to support echo, eval or include no matter what they output (identity or not).

[cscheid]

I'm sort of ok with this being a known bug for a while. When we add the "pre-knitr Pandoc pass" that we've talked about, then OJS cells will be completely handled before knitr is called, and this problem will go away.