doc-detective-common 4.10.0 → 4.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +2254 -28
- package/dist/schemas/schemas.json +2254 -28
- package/dist/types/generated/record_v3.d.ts +25 -2
- package/dist/types/generated/record_v3.d.ts.map +1 -1
- package/dist/types/generated/step_v3.d.ts +25 -2
- package/dist/types/generated/step_v3.d.ts.map +1 -1
- package/dist/types/generated/test_v3.d.ts +50 -4
- package/dist/types/generated/test_v3.d.ts.map +1 -1
- package/package.json +1 -1
package/dist/index.cjs
CHANGED
|
@@ -7567,7 +7567,7 @@ var schemas_default = {
|
|
|
7567
7567
|
record: {
|
|
7568
7568
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
7569
7569
|
title: "record",
|
|
7570
|
-
description: "Start recording
|
|
7570
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
7571
7571
|
anyOf: [
|
|
7572
7572
|
{
|
|
7573
7573
|
title: "Record (simple)",
|
|
@@ -7603,6 +7603,55 @@ var schemas_default = {
|
|
|
7603
7603
|
"true",
|
|
7604
7604
|
"false"
|
|
7605
7605
|
]
|
|
7606
|
+
},
|
|
7607
|
+
engine: {
|
|
7608
|
+
title: "Recording engine",
|
|
7609
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
7610
|
+
anyOf: [
|
|
7611
|
+
{
|
|
7612
|
+
title: "Recording engine (simple)",
|
|
7613
|
+
type: "string",
|
|
7614
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7615
|
+
enum: [
|
|
7616
|
+
"browser",
|
|
7617
|
+
"ffmpeg"
|
|
7618
|
+
]
|
|
7619
|
+
},
|
|
7620
|
+
{
|
|
7621
|
+
title: "Recording engine (detailed)",
|
|
7622
|
+
type: "object",
|
|
7623
|
+
additionalProperties: false,
|
|
7624
|
+
required: [
|
|
7625
|
+
"name"
|
|
7626
|
+
],
|
|
7627
|
+
properties: {
|
|
7628
|
+
name: {
|
|
7629
|
+
type: "string",
|
|
7630
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7631
|
+
enum: [
|
|
7632
|
+
"browser",
|
|
7633
|
+
"ffmpeg"
|
|
7634
|
+
]
|
|
7635
|
+
},
|
|
7636
|
+
target: {
|
|
7637
|
+
type: "string",
|
|
7638
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
7639
|
+
enum: [
|
|
7640
|
+
"display",
|
|
7641
|
+
"window",
|
|
7642
|
+
"viewport"
|
|
7643
|
+
],
|
|
7644
|
+
default: "display"
|
|
7645
|
+
},
|
|
7646
|
+
fps: {
|
|
7647
|
+
type: "integer",
|
|
7648
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
7649
|
+
default: 30,
|
|
7650
|
+
minimum: 1
|
|
7651
|
+
}
|
|
7652
|
+
}
|
|
7653
|
+
}
|
|
7654
|
+
]
|
|
7606
7655
|
}
|
|
7607
7656
|
},
|
|
7608
7657
|
title: "Record (detailed)"
|
|
@@ -7610,7 +7659,7 @@ var schemas_default = {
|
|
|
7610
7659
|
{
|
|
7611
7660
|
type: "boolean",
|
|
7612
7661
|
title: "Record (boolean)",
|
|
7613
|
-
description: "If `true`,
|
|
7662
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
7614
7663
|
}
|
|
7615
7664
|
],
|
|
7616
7665
|
components: {
|
|
@@ -7649,9 +7698,107 @@ var schemas_default = {
|
|
|
7649
7698
|
"true",
|
|
7650
7699
|
"false"
|
|
7651
7700
|
]
|
|
7701
|
+
},
|
|
7702
|
+
engine: {
|
|
7703
|
+
title: "Recording engine",
|
|
7704
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
7705
|
+
anyOf: [
|
|
7706
|
+
{
|
|
7707
|
+
title: "Recording engine (simple)",
|
|
7708
|
+
type: "string",
|
|
7709
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7710
|
+
enum: [
|
|
7711
|
+
"browser",
|
|
7712
|
+
"ffmpeg"
|
|
7713
|
+
]
|
|
7714
|
+
},
|
|
7715
|
+
{
|
|
7716
|
+
title: "Recording engine (detailed)",
|
|
7717
|
+
type: "object",
|
|
7718
|
+
additionalProperties: false,
|
|
7719
|
+
required: [
|
|
7720
|
+
"name"
|
|
7721
|
+
],
|
|
7722
|
+
properties: {
|
|
7723
|
+
name: {
|
|
7724
|
+
type: "string",
|
|
7725
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7726
|
+
enum: [
|
|
7727
|
+
"browser",
|
|
7728
|
+
"ffmpeg"
|
|
7729
|
+
]
|
|
7730
|
+
},
|
|
7731
|
+
target: {
|
|
7732
|
+
type: "string",
|
|
7733
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
7734
|
+
enum: [
|
|
7735
|
+
"display",
|
|
7736
|
+
"window",
|
|
7737
|
+
"viewport"
|
|
7738
|
+
],
|
|
7739
|
+
default: "display"
|
|
7740
|
+
},
|
|
7741
|
+
fps: {
|
|
7742
|
+
type: "integer",
|
|
7743
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
7744
|
+
default: 30,
|
|
7745
|
+
minimum: 1
|
|
7746
|
+
}
|
|
7747
|
+
}
|
|
7748
|
+
}
|
|
7749
|
+
]
|
|
7652
7750
|
}
|
|
7653
7751
|
},
|
|
7654
7752
|
title: "Record (detailed)"
|
|
7753
|
+
},
|
|
7754
|
+
engine: {
|
|
7755
|
+
title: "Recording engine",
|
|
7756
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
7757
|
+
anyOf: [
|
|
7758
|
+
{
|
|
7759
|
+
title: "Recording engine (simple)",
|
|
7760
|
+
type: "string",
|
|
7761
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7762
|
+
enum: [
|
|
7763
|
+
"browser",
|
|
7764
|
+
"ffmpeg"
|
|
7765
|
+
]
|
|
7766
|
+
},
|
|
7767
|
+
{
|
|
7768
|
+
title: "Recording engine (detailed)",
|
|
7769
|
+
type: "object",
|
|
7770
|
+
additionalProperties: false,
|
|
7771
|
+
required: [
|
|
7772
|
+
"name"
|
|
7773
|
+
],
|
|
7774
|
+
properties: {
|
|
7775
|
+
name: {
|
|
7776
|
+
type: "string",
|
|
7777
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
7778
|
+
enum: [
|
|
7779
|
+
"browser",
|
|
7780
|
+
"ffmpeg"
|
|
7781
|
+
]
|
|
7782
|
+
},
|
|
7783
|
+
target: {
|
|
7784
|
+
type: "string",
|
|
7785
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
7786
|
+
enum: [
|
|
7787
|
+
"display",
|
|
7788
|
+
"window",
|
|
7789
|
+
"viewport"
|
|
7790
|
+
],
|
|
7791
|
+
default: "display"
|
|
7792
|
+
},
|
|
7793
|
+
fps: {
|
|
7794
|
+
type: "integer",
|
|
7795
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
7796
|
+
default: 30,
|
|
7797
|
+
minimum: 1
|
|
7798
|
+
}
|
|
7799
|
+
}
|
|
7800
|
+
}
|
|
7801
|
+
]
|
|
7655
7802
|
}
|
|
7656
7803
|
}
|
|
7657
7804
|
},
|
|
@@ -7662,6 +7809,18 @@ var schemas_default = {
|
|
|
7662
7809
|
path: "results.mp4",
|
|
7663
7810
|
directory: "static/media",
|
|
7664
7811
|
overwrite: "true"
|
|
7812
|
+
},
|
|
7813
|
+
{
|
|
7814
|
+
path: "results.mp4",
|
|
7815
|
+
engine: "ffmpeg"
|
|
7816
|
+
},
|
|
7817
|
+
{
|
|
7818
|
+
path: "results.mp4",
|
|
7819
|
+
engine: {
|
|
7820
|
+
name: "ffmpeg",
|
|
7821
|
+
target: "window",
|
|
7822
|
+
fps: 60
|
|
7823
|
+
}
|
|
7665
7824
|
}
|
|
7666
7825
|
]
|
|
7667
7826
|
}
|
|
@@ -16448,7 +16607,7 @@ var schemas_default = {
|
|
|
16448
16607
|
record: {
|
|
16449
16608
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
16450
16609
|
title: "record",
|
|
16451
|
-
description: "Start recording
|
|
16610
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
16452
16611
|
anyOf: [
|
|
16453
16612
|
{
|
|
16454
16613
|
title: "Record (simple)",
|
|
@@ -16484,6 +16643,55 @@ var schemas_default = {
|
|
|
16484
16643
|
"true",
|
|
16485
16644
|
"false"
|
|
16486
16645
|
]
|
|
16646
|
+
},
|
|
16647
|
+
engine: {
|
|
16648
|
+
title: "Recording engine",
|
|
16649
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
16650
|
+
anyOf: [
|
|
16651
|
+
{
|
|
16652
|
+
title: "Recording engine (simple)",
|
|
16653
|
+
type: "string",
|
|
16654
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16655
|
+
enum: [
|
|
16656
|
+
"browser",
|
|
16657
|
+
"ffmpeg"
|
|
16658
|
+
]
|
|
16659
|
+
},
|
|
16660
|
+
{
|
|
16661
|
+
title: "Recording engine (detailed)",
|
|
16662
|
+
type: "object",
|
|
16663
|
+
additionalProperties: false,
|
|
16664
|
+
required: [
|
|
16665
|
+
"name"
|
|
16666
|
+
],
|
|
16667
|
+
properties: {
|
|
16668
|
+
name: {
|
|
16669
|
+
type: "string",
|
|
16670
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16671
|
+
enum: [
|
|
16672
|
+
"browser",
|
|
16673
|
+
"ffmpeg"
|
|
16674
|
+
]
|
|
16675
|
+
},
|
|
16676
|
+
target: {
|
|
16677
|
+
type: "string",
|
|
16678
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
16679
|
+
enum: [
|
|
16680
|
+
"display",
|
|
16681
|
+
"window",
|
|
16682
|
+
"viewport"
|
|
16683
|
+
],
|
|
16684
|
+
default: "display"
|
|
16685
|
+
},
|
|
16686
|
+
fps: {
|
|
16687
|
+
type: "integer",
|
|
16688
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
16689
|
+
default: 30,
|
|
16690
|
+
minimum: 1
|
|
16691
|
+
}
|
|
16692
|
+
}
|
|
16693
|
+
}
|
|
16694
|
+
]
|
|
16487
16695
|
}
|
|
16488
16696
|
},
|
|
16489
16697
|
title: "Record (detailed)"
|
|
@@ -16491,7 +16699,7 @@ var schemas_default = {
|
|
|
16491
16699
|
{
|
|
16492
16700
|
type: "boolean",
|
|
16493
16701
|
title: "Record (boolean)",
|
|
16494
|
-
description: "If `true`,
|
|
16702
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
16495
16703
|
}
|
|
16496
16704
|
],
|
|
16497
16705
|
components: {
|
|
@@ -16530,9 +16738,107 @@ var schemas_default = {
|
|
|
16530
16738
|
"true",
|
|
16531
16739
|
"false"
|
|
16532
16740
|
]
|
|
16741
|
+
},
|
|
16742
|
+
engine: {
|
|
16743
|
+
title: "Recording engine",
|
|
16744
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
16745
|
+
anyOf: [
|
|
16746
|
+
{
|
|
16747
|
+
title: "Recording engine (simple)",
|
|
16748
|
+
type: "string",
|
|
16749
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16750
|
+
enum: [
|
|
16751
|
+
"browser",
|
|
16752
|
+
"ffmpeg"
|
|
16753
|
+
]
|
|
16754
|
+
},
|
|
16755
|
+
{
|
|
16756
|
+
title: "Recording engine (detailed)",
|
|
16757
|
+
type: "object",
|
|
16758
|
+
additionalProperties: false,
|
|
16759
|
+
required: [
|
|
16760
|
+
"name"
|
|
16761
|
+
],
|
|
16762
|
+
properties: {
|
|
16763
|
+
name: {
|
|
16764
|
+
type: "string",
|
|
16765
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16766
|
+
enum: [
|
|
16767
|
+
"browser",
|
|
16768
|
+
"ffmpeg"
|
|
16769
|
+
]
|
|
16770
|
+
},
|
|
16771
|
+
target: {
|
|
16772
|
+
type: "string",
|
|
16773
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
16774
|
+
enum: [
|
|
16775
|
+
"display",
|
|
16776
|
+
"window",
|
|
16777
|
+
"viewport"
|
|
16778
|
+
],
|
|
16779
|
+
default: "display"
|
|
16780
|
+
},
|
|
16781
|
+
fps: {
|
|
16782
|
+
type: "integer",
|
|
16783
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
16784
|
+
default: 30,
|
|
16785
|
+
minimum: 1
|
|
16786
|
+
}
|
|
16787
|
+
}
|
|
16788
|
+
}
|
|
16789
|
+
]
|
|
16533
16790
|
}
|
|
16534
16791
|
},
|
|
16535
16792
|
title: "Record (detailed)"
|
|
16793
|
+
},
|
|
16794
|
+
engine: {
|
|
16795
|
+
title: "Recording engine",
|
|
16796
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
16797
|
+
anyOf: [
|
|
16798
|
+
{
|
|
16799
|
+
title: "Recording engine (simple)",
|
|
16800
|
+
type: "string",
|
|
16801
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16802
|
+
enum: [
|
|
16803
|
+
"browser",
|
|
16804
|
+
"ffmpeg"
|
|
16805
|
+
]
|
|
16806
|
+
},
|
|
16807
|
+
{
|
|
16808
|
+
title: "Recording engine (detailed)",
|
|
16809
|
+
type: "object",
|
|
16810
|
+
additionalProperties: false,
|
|
16811
|
+
required: [
|
|
16812
|
+
"name"
|
|
16813
|
+
],
|
|
16814
|
+
properties: {
|
|
16815
|
+
name: {
|
|
16816
|
+
type: "string",
|
|
16817
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
16818
|
+
enum: [
|
|
16819
|
+
"browser",
|
|
16820
|
+
"ffmpeg"
|
|
16821
|
+
]
|
|
16822
|
+
},
|
|
16823
|
+
target: {
|
|
16824
|
+
type: "string",
|
|
16825
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
16826
|
+
enum: [
|
|
16827
|
+
"display",
|
|
16828
|
+
"window",
|
|
16829
|
+
"viewport"
|
|
16830
|
+
],
|
|
16831
|
+
default: "display"
|
|
16832
|
+
},
|
|
16833
|
+
fps: {
|
|
16834
|
+
type: "integer",
|
|
16835
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
16836
|
+
default: 30,
|
|
16837
|
+
minimum: 1
|
|
16838
|
+
}
|
|
16839
|
+
}
|
|
16840
|
+
}
|
|
16841
|
+
]
|
|
16536
16842
|
}
|
|
16537
16843
|
}
|
|
16538
16844
|
},
|
|
@@ -16543,6 +16849,18 @@ var schemas_default = {
|
|
|
16543
16849
|
path: "results.mp4",
|
|
16544
16850
|
directory: "static/media",
|
|
16545
16851
|
overwrite: "true"
|
|
16852
|
+
},
|
|
16853
|
+
{
|
|
16854
|
+
path: "results.mp4",
|
|
16855
|
+
engine: "ffmpeg"
|
|
16856
|
+
},
|
|
16857
|
+
{
|
|
16858
|
+
path: "results.mp4",
|
|
16859
|
+
engine: {
|
|
16860
|
+
name: "ffmpeg",
|
|
16861
|
+
target: "window",
|
|
16862
|
+
fps: 60
|
|
16863
|
+
}
|
|
16546
16864
|
}
|
|
16547
16865
|
]
|
|
16548
16866
|
}
|
|
@@ -22604,7 +22922,7 @@ var schemas_default = {
|
|
|
22604
22922
|
record_v3: {
|
|
22605
22923
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
22606
22924
|
title: "record",
|
|
22607
|
-
description: "Start recording
|
|
22925
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
22608
22926
|
anyOf: [
|
|
22609
22927
|
{
|
|
22610
22928
|
title: "Record (simple)",
|
|
@@ -22640,6 +22958,55 @@ var schemas_default = {
|
|
|
22640
22958
|
"true",
|
|
22641
22959
|
"false"
|
|
22642
22960
|
]
|
|
22961
|
+
},
|
|
22962
|
+
engine: {
|
|
22963
|
+
title: "Recording engine",
|
|
22964
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
22965
|
+
anyOf: [
|
|
22966
|
+
{
|
|
22967
|
+
title: "Recording engine (simple)",
|
|
22968
|
+
type: "string",
|
|
22969
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
22970
|
+
enum: [
|
|
22971
|
+
"browser",
|
|
22972
|
+
"ffmpeg"
|
|
22973
|
+
]
|
|
22974
|
+
},
|
|
22975
|
+
{
|
|
22976
|
+
title: "Recording engine (detailed)",
|
|
22977
|
+
type: "object",
|
|
22978
|
+
additionalProperties: false,
|
|
22979
|
+
required: [
|
|
22980
|
+
"name"
|
|
22981
|
+
],
|
|
22982
|
+
properties: {
|
|
22983
|
+
name: {
|
|
22984
|
+
type: "string",
|
|
22985
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
22986
|
+
enum: [
|
|
22987
|
+
"browser",
|
|
22988
|
+
"ffmpeg"
|
|
22989
|
+
]
|
|
22990
|
+
},
|
|
22991
|
+
target: {
|
|
22992
|
+
type: "string",
|
|
22993
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
22994
|
+
enum: [
|
|
22995
|
+
"display",
|
|
22996
|
+
"window",
|
|
22997
|
+
"viewport"
|
|
22998
|
+
],
|
|
22999
|
+
default: "display"
|
|
23000
|
+
},
|
|
23001
|
+
fps: {
|
|
23002
|
+
type: "integer",
|
|
23003
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
23004
|
+
default: 30,
|
|
23005
|
+
minimum: 1
|
|
23006
|
+
}
|
|
23007
|
+
}
|
|
23008
|
+
}
|
|
23009
|
+
]
|
|
22643
23010
|
}
|
|
22644
23011
|
},
|
|
22645
23012
|
title: "Record (detailed)"
|
|
@@ -22647,7 +23014,7 @@ var schemas_default = {
|
|
|
22647
23014
|
{
|
|
22648
23015
|
type: "boolean",
|
|
22649
23016
|
title: "Record (boolean)",
|
|
22650
|
-
description: "If `true`,
|
|
23017
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
22651
23018
|
}
|
|
22652
23019
|
],
|
|
22653
23020
|
components: {
|
|
@@ -22686,9 +23053,107 @@ var schemas_default = {
|
|
|
22686
23053
|
"true",
|
|
22687
23054
|
"false"
|
|
22688
23055
|
]
|
|
23056
|
+
},
|
|
23057
|
+
engine: {
|
|
23058
|
+
title: "Recording engine",
|
|
23059
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
23060
|
+
anyOf: [
|
|
23061
|
+
{
|
|
23062
|
+
title: "Recording engine (simple)",
|
|
23063
|
+
type: "string",
|
|
23064
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
23065
|
+
enum: [
|
|
23066
|
+
"browser",
|
|
23067
|
+
"ffmpeg"
|
|
23068
|
+
]
|
|
23069
|
+
},
|
|
23070
|
+
{
|
|
23071
|
+
title: "Recording engine (detailed)",
|
|
23072
|
+
type: "object",
|
|
23073
|
+
additionalProperties: false,
|
|
23074
|
+
required: [
|
|
23075
|
+
"name"
|
|
23076
|
+
],
|
|
23077
|
+
properties: {
|
|
23078
|
+
name: {
|
|
23079
|
+
type: "string",
|
|
23080
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
23081
|
+
enum: [
|
|
23082
|
+
"browser",
|
|
23083
|
+
"ffmpeg"
|
|
23084
|
+
]
|
|
23085
|
+
},
|
|
23086
|
+
target: {
|
|
23087
|
+
type: "string",
|
|
23088
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
23089
|
+
enum: [
|
|
23090
|
+
"display",
|
|
23091
|
+
"window",
|
|
23092
|
+
"viewport"
|
|
23093
|
+
],
|
|
23094
|
+
default: "display"
|
|
23095
|
+
},
|
|
23096
|
+
fps: {
|
|
23097
|
+
type: "integer",
|
|
23098
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
23099
|
+
default: 30,
|
|
23100
|
+
minimum: 1
|
|
23101
|
+
}
|
|
23102
|
+
}
|
|
23103
|
+
}
|
|
23104
|
+
]
|
|
22689
23105
|
}
|
|
22690
23106
|
},
|
|
22691
23107
|
title: "Record (detailed)"
|
|
23108
|
+
},
|
|
23109
|
+
engine: {
|
|
23110
|
+
title: "Recording engine",
|
|
23111
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
23112
|
+
anyOf: [
|
|
23113
|
+
{
|
|
23114
|
+
title: "Recording engine (simple)",
|
|
23115
|
+
type: "string",
|
|
23116
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
23117
|
+
enum: [
|
|
23118
|
+
"browser",
|
|
23119
|
+
"ffmpeg"
|
|
23120
|
+
]
|
|
23121
|
+
},
|
|
23122
|
+
{
|
|
23123
|
+
title: "Recording engine (detailed)",
|
|
23124
|
+
type: "object",
|
|
23125
|
+
additionalProperties: false,
|
|
23126
|
+
required: [
|
|
23127
|
+
"name"
|
|
23128
|
+
],
|
|
23129
|
+
properties: {
|
|
23130
|
+
name: {
|
|
23131
|
+
type: "string",
|
|
23132
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
23133
|
+
enum: [
|
|
23134
|
+
"browser",
|
|
23135
|
+
"ffmpeg"
|
|
23136
|
+
]
|
|
23137
|
+
},
|
|
23138
|
+
target: {
|
|
23139
|
+
type: "string",
|
|
23140
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
23141
|
+
enum: [
|
|
23142
|
+
"display",
|
|
23143
|
+
"window",
|
|
23144
|
+
"viewport"
|
|
23145
|
+
],
|
|
23146
|
+
default: "display"
|
|
23147
|
+
},
|
|
23148
|
+
fps: {
|
|
23149
|
+
type: "integer",
|
|
23150
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
23151
|
+
default: 30,
|
|
23152
|
+
minimum: 1
|
|
23153
|
+
}
|
|
23154
|
+
}
|
|
23155
|
+
}
|
|
23156
|
+
]
|
|
22692
23157
|
}
|
|
22693
23158
|
}
|
|
22694
23159
|
},
|
|
@@ -22699,6 +23164,18 @@ var schemas_default = {
|
|
|
22699
23164
|
path: "results.mp4",
|
|
22700
23165
|
directory: "static/media",
|
|
22701
23166
|
overwrite: "true"
|
|
23167
|
+
},
|
|
23168
|
+
{
|
|
23169
|
+
path: "results.mp4",
|
|
23170
|
+
engine: "ffmpeg"
|
|
23171
|
+
},
|
|
23172
|
+
{
|
|
23173
|
+
path: "results.mp4",
|
|
23174
|
+
engine: {
|
|
23175
|
+
name: "ffmpeg",
|
|
23176
|
+
target: "window",
|
|
23177
|
+
fps: 60
|
|
23178
|
+
}
|
|
22702
23179
|
}
|
|
22703
23180
|
]
|
|
22704
23181
|
},
|
|
@@ -29782,7 +30259,7 @@ var schemas_default = {
|
|
|
29782
30259
|
record: {
|
|
29783
30260
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
29784
30261
|
title: "record",
|
|
29785
|
-
description: "Start recording
|
|
30262
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
29786
30263
|
anyOf: [
|
|
29787
30264
|
{
|
|
29788
30265
|
title: "Record (simple)",
|
|
@@ -29818,6 +30295,55 @@ var schemas_default = {
|
|
|
29818
30295
|
"true",
|
|
29819
30296
|
"false"
|
|
29820
30297
|
]
|
|
30298
|
+
},
|
|
30299
|
+
engine: {
|
|
30300
|
+
title: "Recording engine",
|
|
30301
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
30302
|
+
anyOf: [
|
|
30303
|
+
{
|
|
30304
|
+
title: "Recording engine (simple)",
|
|
30305
|
+
type: "string",
|
|
30306
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30307
|
+
enum: [
|
|
30308
|
+
"browser",
|
|
30309
|
+
"ffmpeg"
|
|
30310
|
+
]
|
|
30311
|
+
},
|
|
30312
|
+
{
|
|
30313
|
+
title: "Recording engine (detailed)",
|
|
30314
|
+
type: "object",
|
|
30315
|
+
additionalProperties: false,
|
|
30316
|
+
required: [
|
|
30317
|
+
"name"
|
|
30318
|
+
],
|
|
30319
|
+
properties: {
|
|
30320
|
+
name: {
|
|
30321
|
+
type: "string",
|
|
30322
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30323
|
+
enum: [
|
|
30324
|
+
"browser",
|
|
30325
|
+
"ffmpeg"
|
|
30326
|
+
]
|
|
30327
|
+
},
|
|
30328
|
+
target: {
|
|
30329
|
+
type: "string",
|
|
30330
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
30331
|
+
enum: [
|
|
30332
|
+
"display",
|
|
30333
|
+
"window",
|
|
30334
|
+
"viewport"
|
|
30335
|
+
],
|
|
30336
|
+
default: "display"
|
|
30337
|
+
},
|
|
30338
|
+
fps: {
|
|
30339
|
+
type: "integer",
|
|
30340
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
30341
|
+
default: 30,
|
|
30342
|
+
minimum: 1
|
|
30343
|
+
}
|
|
30344
|
+
}
|
|
30345
|
+
}
|
|
30346
|
+
]
|
|
29821
30347
|
}
|
|
29822
30348
|
},
|
|
29823
30349
|
title: "Record (detailed)"
|
|
@@ -29825,7 +30351,7 @@ var schemas_default = {
|
|
|
29825
30351
|
{
|
|
29826
30352
|
type: "boolean",
|
|
29827
30353
|
title: "Record (boolean)",
|
|
29828
|
-
description: "If `true`,
|
|
30354
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
29829
30355
|
}
|
|
29830
30356
|
],
|
|
29831
30357
|
components: {
|
|
@@ -29864,9 +30390,107 @@ var schemas_default = {
|
|
|
29864
30390
|
"true",
|
|
29865
30391
|
"false"
|
|
29866
30392
|
]
|
|
30393
|
+
},
|
|
30394
|
+
engine: {
|
|
30395
|
+
title: "Recording engine",
|
|
30396
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
30397
|
+
anyOf: [
|
|
30398
|
+
{
|
|
30399
|
+
title: "Recording engine (simple)",
|
|
30400
|
+
type: "string",
|
|
30401
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30402
|
+
enum: [
|
|
30403
|
+
"browser",
|
|
30404
|
+
"ffmpeg"
|
|
30405
|
+
]
|
|
30406
|
+
},
|
|
30407
|
+
{
|
|
30408
|
+
title: "Recording engine (detailed)",
|
|
30409
|
+
type: "object",
|
|
30410
|
+
additionalProperties: false,
|
|
30411
|
+
required: [
|
|
30412
|
+
"name"
|
|
30413
|
+
],
|
|
30414
|
+
properties: {
|
|
30415
|
+
name: {
|
|
30416
|
+
type: "string",
|
|
30417
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30418
|
+
enum: [
|
|
30419
|
+
"browser",
|
|
30420
|
+
"ffmpeg"
|
|
30421
|
+
]
|
|
30422
|
+
},
|
|
30423
|
+
target: {
|
|
30424
|
+
type: "string",
|
|
30425
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
30426
|
+
enum: [
|
|
30427
|
+
"display",
|
|
30428
|
+
"window",
|
|
30429
|
+
"viewport"
|
|
30430
|
+
],
|
|
30431
|
+
default: "display"
|
|
30432
|
+
},
|
|
30433
|
+
fps: {
|
|
30434
|
+
type: "integer",
|
|
30435
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
30436
|
+
default: 30,
|
|
30437
|
+
minimum: 1
|
|
30438
|
+
}
|
|
30439
|
+
}
|
|
30440
|
+
}
|
|
30441
|
+
]
|
|
29867
30442
|
}
|
|
29868
30443
|
},
|
|
29869
30444
|
title: "Record (detailed)"
|
|
30445
|
+
},
|
|
30446
|
+
engine: {
|
|
30447
|
+
title: "Recording engine",
|
|
30448
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
30449
|
+
anyOf: [
|
|
30450
|
+
{
|
|
30451
|
+
title: "Recording engine (simple)",
|
|
30452
|
+
type: "string",
|
|
30453
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30454
|
+
enum: [
|
|
30455
|
+
"browser",
|
|
30456
|
+
"ffmpeg"
|
|
30457
|
+
]
|
|
30458
|
+
},
|
|
30459
|
+
{
|
|
30460
|
+
title: "Recording engine (detailed)",
|
|
30461
|
+
type: "object",
|
|
30462
|
+
additionalProperties: false,
|
|
30463
|
+
required: [
|
|
30464
|
+
"name"
|
|
30465
|
+
],
|
|
30466
|
+
properties: {
|
|
30467
|
+
name: {
|
|
30468
|
+
type: "string",
|
|
30469
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
30470
|
+
enum: [
|
|
30471
|
+
"browser",
|
|
30472
|
+
"ffmpeg"
|
|
30473
|
+
]
|
|
30474
|
+
},
|
|
30475
|
+
target: {
|
|
30476
|
+
type: "string",
|
|
30477
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
30478
|
+
enum: [
|
|
30479
|
+
"display",
|
|
30480
|
+
"window",
|
|
30481
|
+
"viewport"
|
|
30482
|
+
],
|
|
30483
|
+
default: "display"
|
|
30484
|
+
},
|
|
30485
|
+
fps: {
|
|
30486
|
+
type: "integer",
|
|
30487
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
30488
|
+
default: 30,
|
|
30489
|
+
minimum: 1
|
|
30490
|
+
}
|
|
30491
|
+
}
|
|
30492
|
+
}
|
|
30493
|
+
]
|
|
29870
30494
|
}
|
|
29871
30495
|
}
|
|
29872
30496
|
},
|
|
@@ -29877,6 +30501,18 @@ var schemas_default = {
|
|
|
29877
30501
|
path: "results.mp4",
|
|
29878
30502
|
directory: "static/media",
|
|
29879
30503
|
overwrite: "true"
|
|
30504
|
+
},
|
|
30505
|
+
{
|
|
30506
|
+
path: "results.mp4",
|
|
30507
|
+
engine: "ffmpeg"
|
|
30508
|
+
},
|
|
30509
|
+
{
|
|
30510
|
+
path: "results.mp4",
|
|
30511
|
+
engine: {
|
|
30512
|
+
name: "ffmpeg",
|
|
30513
|
+
target: "window",
|
|
30514
|
+
fps: 60
|
|
30515
|
+
}
|
|
29880
30516
|
}
|
|
29881
30517
|
]
|
|
29882
30518
|
}
|
|
@@ -38663,7 +39299,7 @@ var schemas_default = {
|
|
|
38663
39299
|
record: {
|
|
38664
39300
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
38665
39301
|
title: "record",
|
|
38666
|
-
description: "Start recording
|
|
39302
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
38667
39303
|
anyOf: [
|
|
38668
39304
|
{
|
|
38669
39305
|
title: "Record (simple)",
|
|
@@ -38699,6 +39335,55 @@ var schemas_default = {
|
|
|
38699
39335
|
"true",
|
|
38700
39336
|
"false"
|
|
38701
39337
|
]
|
|
39338
|
+
},
|
|
39339
|
+
engine: {
|
|
39340
|
+
title: "Recording engine",
|
|
39341
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
39342
|
+
anyOf: [
|
|
39343
|
+
{
|
|
39344
|
+
title: "Recording engine (simple)",
|
|
39345
|
+
type: "string",
|
|
39346
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39347
|
+
enum: [
|
|
39348
|
+
"browser",
|
|
39349
|
+
"ffmpeg"
|
|
39350
|
+
]
|
|
39351
|
+
},
|
|
39352
|
+
{
|
|
39353
|
+
title: "Recording engine (detailed)",
|
|
39354
|
+
type: "object",
|
|
39355
|
+
additionalProperties: false,
|
|
39356
|
+
required: [
|
|
39357
|
+
"name"
|
|
39358
|
+
],
|
|
39359
|
+
properties: {
|
|
39360
|
+
name: {
|
|
39361
|
+
type: "string",
|
|
39362
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39363
|
+
enum: [
|
|
39364
|
+
"browser",
|
|
39365
|
+
"ffmpeg"
|
|
39366
|
+
]
|
|
39367
|
+
},
|
|
39368
|
+
target: {
|
|
39369
|
+
type: "string",
|
|
39370
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
39371
|
+
enum: [
|
|
39372
|
+
"display",
|
|
39373
|
+
"window",
|
|
39374
|
+
"viewport"
|
|
39375
|
+
],
|
|
39376
|
+
default: "display"
|
|
39377
|
+
},
|
|
39378
|
+
fps: {
|
|
39379
|
+
type: "integer",
|
|
39380
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
39381
|
+
default: 30,
|
|
39382
|
+
minimum: 1
|
|
39383
|
+
}
|
|
39384
|
+
}
|
|
39385
|
+
}
|
|
39386
|
+
]
|
|
38702
39387
|
}
|
|
38703
39388
|
},
|
|
38704
39389
|
title: "Record (detailed)"
|
|
@@ -38706,7 +39391,7 @@ var schemas_default = {
|
|
|
38706
39391
|
{
|
|
38707
39392
|
type: "boolean",
|
|
38708
39393
|
title: "Record (boolean)",
|
|
38709
|
-
description: "If `true`,
|
|
39394
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
38710
39395
|
}
|
|
38711
39396
|
],
|
|
38712
39397
|
components: {
|
|
@@ -38745,9 +39430,107 @@ var schemas_default = {
|
|
|
38745
39430
|
"true",
|
|
38746
39431
|
"false"
|
|
38747
39432
|
]
|
|
39433
|
+
},
|
|
39434
|
+
engine: {
|
|
39435
|
+
title: "Recording engine",
|
|
39436
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
39437
|
+
anyOf: [
|
|
39438
|
+
{
|
|
39439
|
+
title: "Recording engine (simple)",
|
|
39440
|
+
type: "string",
|
|
39441
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39442
|
+
enum: [
|
|
39443
|
+
"browser",
|
|
39444
|
+
"ffmpeg"
|
|
39445
|
+
]
|
|
39446
|
+
},
|
|
39447
|
+
{
|
|
39448
|
+
title: "Recording engine (detailed)",
|
|
39449
|
+
type: "object",
|
|
39450
|
+
additionalProperties: false,
|
|
39451
|
+
required: [
|
|
39452
|
+
"name"
|
|
39453
|
+
],
|
|
39454
|
+
properties: {
|
|
39455
|
+
name: {
|
|
39456
|
+
type: "string",
|
|
39457
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39458
|
+
enum: [
|
|
39459
|
+
"browser",
|
|
39460
|
+
"ffmpeg"
|
|
39461
|
+
]
|
|
39462
|
+
},
|
|
39463
|
+
target: {
|
|
39464
|
+
type: "string",
|
|
39465
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
39466
|
+
enum: [
|
|
39467
|
+
"display",
|
|
39468
|
+
"window",
|
|
39469
|
+
"viewport"
|
|
39470
|
+
],
|
|
39471
|
+
default: "display"
|
|
39472
|
+
},
|
|
39473
|
+
fps: {
|
|
39474
|
+
type: "integer",
|
|
39475
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
39476
|
+
default: 30,
|
|
39477
|
+
minimum: 1
|
|
39478
|
+
}
|
|
39479
|
+
}
|
|
39480
|
+
}
|
|
39481
|
+
]
|
|
38748
39482
|
}
|
|
38749
39483
|
},
|
|
38750
39484
|
title: "Record (detailed)"
|
|
39485
|
+
},
|
|
39486
|
+
engine: {
|
|
39487
|
+
title: "Recording engine",
|
|
39488
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
39489
|
+
anyOf: [
|
|
39490
|
+
{
|
|
39491
|
+
title: "Recording engine (simple)",
|
|
39492
|
+
type: "string",
|
|
39493
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39494
|
+
enum: [
|
|
39495
|
+
"browser",
|
|
39496
|
+
"ffmpeg"
|
|
39497
|
+
]
|
|
39498
|
+
},
|
|
39499
|
+
{
|
|
39500
|
+
title: "Recording engine (detailed)",
|
|
39501
|
+
type: "object",
|
|
39502
|
+
additionalProperties: false,
|
|
39503
|
+
required: [
|
|
39504
|
+
"name"
|
|
39505
|
+
],
|
|
39506
|
+
properties: {
|
|
39507
|
+
name: {
|
|
39508
|
+
type: "string",
|
|
39509
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
39510
|
+
enum: [
|
|
39511
|
+
"browser",
|
|
39512
|
+
"ffmpeg"
|
|
39513
|
+
]
|
|
39514
|
+
},
|
|
39515
|
+
target: {
|
|
39516
|
+
type: "string",
|
|
39517
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
39518
|
+
enum: [
|
|
39519
|
+
"display",
|
|
39520
|
+
"window",
|
|
39521
|
+
"viewport"
|
|
39522
|
+
],
|
|
39523
|
+
default: "display"
|
|
39524
|
+
},
|
|
39525
|
+
fps: {
|
|
39526
|
+
type: "integer",
|
|
39527
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
39528
|
+
default: 30,
|
|
39529
|
+
minimum: 1
|
|
39530
|
+
}
|
|
39531
|
+
}
|
|
39532
|
+
}
|
|
39533
|
+
]
|
|
38751
39534
|
}
|
|
38752
39535
|
}
|
|
38753
39536
|
},
|
|
@@ -38758,6 +39541,18 @@ var schemas_default = {
|
|
|
38758
39541
|
path: "results.mp4",
|
|
38759
39542
|
directory: "static/media",
|
|
38760
39543
|
overwrite: "true"
|
|
39544
|
+
},
|
|
39545
|
+
{
|
|
39546
|
+
path: "results.mp4",
|
|
39547
|
+
engine: "ffmpeg"
|
|
39548
|
+
},
|
|
39549
|
+
{
|
|
39550
|
+
path: "results.mp4",
|
|
39551
|
+
engine: {
|
|
39552
|
+
name: "ffmpeg",
|
|
39553
|
+
target: "window",
|
|
39554
|
+
fps: 60
|
|
39555
|
+
}
|
|
38761
39556
|
}
|
|
38762
39557
|
]
|
|
38763
39558
|
}
|
|
@@ -48219,7 +49014,7 @@ var schemas_default = {
|
|
|
48219
49014
|
record: {
|
|
48220
49015
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
48221
49016
|
title: "record",
|
|
48222
|
-
description: "Start recording
|
|
49017
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
48223
49018
|
anyOf: [
|
|
48224
49019
|
{
|
|
48225
49020
|
title: "Record (simple)",
|
|
@@ -48255,6 +49050,55 @@ var schemas_default = {
|
|
|
48255
49050
|
"true",
|
|
48256
49051
|
"false"
|
|
48257
49052
|
]
|
|
49053
|
+
},
|
|
49054
|
+
engine: {
|
|
49055
|
+
title: "Recording engine",
|
|
49056
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
49057
|
+
anyOf: [
|
|
49058
|
+
{
|
|
49059
|
+
title: "Recording engine (simple)",
|
|
49060
|
+
type: "string",
|
|
49061
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49062
|
+
enum: [
|
|
49063
|
+
"browser",
|
|
49064
|
+
"ffmpeg"
|
|
49065
|
+
]
|
|
49066
|
+
},
|
|
49067
|
+
{
|
|
49068
|
+
title: "Recording engine (detailed)",
|
|
49069
|
+
type: "object",
|
|
49070
|
+
additionalProperties: false,
|
|
49071
|
+
required: [
|
|
49072
|
+
"name"
|
|
49073
|
+
],
|
|
49074
|
+
properties: {
|
|
49075
|
+
name: {
|
|
49076
|
+
type: "string",
|
|
49077
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49078
|
+
enum: [
|
|
49079
|
+
"browser",
|
|
49080
|
+
"ffmpeg"
|
|
49081
|
+
]
|
|
49082
|
+
},
|
|
49083
|
+
target: {
|
|
49084
|
+
type: "string",
|
|
49085
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
49086
|
+
enum: [
|
|
49087
|
+
"display",
|
|
49088
|
+
"window",
|
|
49089
|
+
"viewport"
|
|
49090
|
+
],
|
|
49091
|
+
default: "display"
|
|
49092
|
+
},
|
|
49093
|
+
fps: {
|
|
49094
|
+
type: "integer",
|
|
49095
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
49096
|
+
default: 30,
|
|
49097
|
+
minimum: 1
|
|
49098
|
+
}
|
|
49099
|
+
}
|
|
49100
|
+
}
|
|
49101
|
+
]
|
|
48258
49102
|
}
|
|
48259
49103
|
},
|
|
48260
49104
|
title: "Record (detailed)"
|
|
@@ -48262,7 +49106,7 @@ var schemas_default = {
|
|
|
48262
49106
|
{
|
|
48263
49107
|
type: "boolean",
|
|
48264
49108
|
title: "Record (boolean)",
|
|
48265
|
-
description: "If `true`,
|
|
49109
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
48266
49110
|
}
|
|
48267
49111
|
],
|
|
48268
49112
|
components: {
|
|
@@ -48301,9 +49145,107 @@ var schemas_default = {
|
|
|
48301
49145
|
"true",
|
|
48302
49146
|
"false"
|
|
48303
49147
|
]
|
|
49148
|
+
},
|
|
49149
|
+
engine: {
|
|
49150
|
+
title: "Recording engine",
|
|
49151
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
49152
|
+
anyOf: [
|
|
49153
|
+
{
|
|
49154
|
+
title: "Recording engine (simple)",
|
|
49155
|
+
type: "string",
|
|
49156
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49157
|
+
enum: [
|
|
49158
|
+
"browser",
|
|
49159
|
+
"ffmpeg"
|
|
49160
|
+
]
|
|
49161
|
+
},
|
|
49162
|
+
{
|
|
49163
|
+
title: "Recording engine (detailed)",
|
|
49164
|
+
type: "object",
|
|
49165
|
+
additionalProperties: false,
|
|
49166
|
+
required: [
|
|
49167
|
+
"name"
|
|
49168
|
+
],
|
|
49169
|
+
properties: {
|
|
49170
|
+
name: {
|
|
49171
|
+
type: "string",
|
|
49172
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49173
|
+
enum: [
|
|
49174
|
+
"browser",
|
|
49175
|
+
"ffmpeg"
|
|
49176
|
+
]
|
|
49177
|
+
},
|
|
49178
|
+
target: {
|
|
49179
|
+
type: "string",
|
|
49180
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
49181
|
+
enum: [
|
|
49182
|
+
"display",
|
|
49183
|
+
"window",
|
|
49184
|
+
"viewport"
|
|
49185
|
+
],
|
|
49186
|
+
default: "display"
|
|
49187
|
+
},
|
|
49188
|
+
fps: {
|
|
49189
|
+
type: "integer",
|
|
49190
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
49191
|
+
default: 30,
|
|
49192
|
+
minimum: 1
|
|
49193
|
+
}
|
|
49194
|
+
}
|
|
49195
|
+
}
|
|
49196
|
+
]
|
|
48304
49197
|
}
|
|
48305
49198
|
},
|
|
48306
49199
|
title: "Record (detailed)"
|
|
49200
|
+
},
|
|
49201
|
+
engine: {
|
|
49202
|
+
title: "Recording engine",
|
|
49203
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
49204
|
+
anyOf: [
|
|
49205
|
+
{
|
|
49206
|
+
title: "Recording engine (simple)",
|
|
49207
|
+
type: "string",
|
|
49208
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49209
|
+
enum: [
|
|
49210
|
+
"browser",
|
|
49211
|
+
"ffmpeg"
|
|
49212
|
+
]
|
|
49213
|
+
},
|
|
49214
|
+
{
|
|
49215
|
+
title: "Recording engine (detailed)",
|
|
49216
|
+
type: "object",
|
|
49217
|
+
additionalProperties: false,
|
|
49218
|
+
required: [
|
|
49219
|
+
"name"
|
|
49220
|
+
],
|
|
49221
|
+
properties: {
|
|
49222
|
+
name: {
|
|
49223
|
+
type: "string",
|
|
49224
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
49225
|
+
enum: [
|
|
49226
|
+
"browser",
|
|
49227
|
+
"ffmpeg"
|
|
49228
|
+
]
|
|
49229
|
+
},
|
|
49230
|
+
target: {
|
|
49231
|
+
type: "string",
|
|
49232
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
49233
|
+
enum: [
|
|
49234
|
+
"display",
|
|
49235
|
+
"window",
|
|
49236
|
+
"viewport"
|
|
49237
|
+
],
|
|
49238
|
+
default: "display"
|
|
49239
|
+
},
|
|
49240
|
+
fps: {
|
|
49241
|
+
type: "integer",
|
|
49242
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
49243
|
+
default: 30,
|
|
49244
|
+
minimum: 1
|
|
49245
|
+
}
|
|
49246
|
+
}
|
|
49247
|
+
}
|
|
49248
|
+
]
|
|
48307
49249
|
}
|
|
48308
49250
|
}
|
|
48309
49251
|
},
|
|
@@ -48314,6 +49256,18 @@ var schemas_default = {
|
|
|
48314
49256
|
path: "results.mp4",
|
|
48315
49257
|
directory: "static/media",
|
|
48316
49258
|
overwrite: "true"
|
|
49259
|
+
},
|
|
49260
|
+
{
|
|
49261
|
+
path: "results.mp4",
|
|
49262
|
+
engine: "ffmpeg"
|
|
49263
|
+
},
|
|
49264
|
+
{
|
|
49265
|
+
path: "results.mp4",
|
|
49266
|
+
engine: {
|
|
49267
|
+
name: "ffmpeg",
|
|
49268
|
+
target: "window",
|
|
49269
|
+
fps: 60
|
|
49270
|
+
}
|
|
48317
49271
|
}
|
|
48318
49272
|
]
|
|
48319
49273
|
}
|
|
@@ -56534,7 +57488,7 @@ var schemas_default = {
|
|
|
56534
57488
|
record: {
|
|
56535
57489
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
56536
57490
|
title: "record",
|
|
56537
|
-
description: "Start recording
|
|
57491
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
56538
57492
|
anyOf: [
|
|
56539
57493
|
{
|
|
56540
57494
|
title: "Record (simple)",
|
|
@@ -56570,6 +57524,55 @@ var schemas_default = {
|
|
|
56570
57524
|
"true",
|
|
56571
57525
|
"false"
|
|
56572
57526
|
]
|
|
57527
|
+
},
|
|
57528
|
+
engine: {
|
|
57529
|
+
title: "Recording engine",
|
|
57530
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
57531
|
+
anyOf: [
|
|
57532
|
+
{
|
|
57533
|
+
title: "Recording engine (simple)",
|
|
57534
|
+
type: "string",
|
|
57535
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57536
|
+
enum: [
|
|
57537
|
+
"browser",
|
|
57538
|
+
"ffmpeg"
|
|
57539
|
+
]
|
|
57540
|
+
},
|
|
57541
|
+
{
|
|
57542
|
+
title: "Recording engine (detailed)",
|
|
57543
|
+
type: "object",
|
|
57544
|
+
additionalProperties: false,
|
|
57545
|
+
required: [
|
|
57546
|
+
"name"
|
|
57547
|
+
],
|
|
57548
|
+
properties: {
|
|
57549
|
+
name: {
|
|
57550
|
+
type: "string",
|
|
57551
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57552
|
+
enum: [
|
|
57553
|
+
"browser",
|
|
57554
|
+
"ffmpeg"
|
|
57555
|
+
]
|
|
57556
|
+
},
|
|
57557
|
+
target: {
|
|
57558
|
+
type: "string",
|
|
57559
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
57560
|
+
enum: [
|
|
57561
|
+
"display",
|
|
57562
|
+
"window",
|
|
57563
|
+
"viewport"
|
|
57564
|
+
],
|
|
57565
|
+
default: "display"
|
|
57566
|
+
},
|
|
57567
|
+
fps: {
|
|
57568
|
+
type: "integer",
|
|
57569
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
57570
|
+
default: 30,
|
|
57571
|
+
minimum: 1
|
|
57572
|
+
}
|
|
57573
|
+
}
|
|
57574
|
+
}
|
|
57575
|
+
]
|
|
56573
57576
|
}
|
|
56574
57577
|
},
|
|
56575
57578
|
title: "Record (detailed)"
|
|
@@ -56577,7 +57580,7 @@ var schemas_default = {
|
|
|
56577
57580
|
{
|
|
56578
57581
|
type: "boolean",
|
|
56579
57582
|
title: "Record (boolean)",
|
|
56580
|
-
description: "If `true`,
|
|
57583
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
56581
57584
|
}
|
|
56582
57585
|
],
|
|
56583
57586
|
components: {
|
|
@@ -56616,9 +57619,107 @@ var schemas_default = {
|
|
|
56616
57619
|
"true",
|
|
56617
57620
|
"false"
|
|
56618
57621
|
]
|
|
57622
|
+
},
|
|
57623
|
+
engine: {
|
|
57624
|
+
title: "Recording engine",
|
|
57625
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
57626
|
+
anyOf: [
|
|
57627
|
+
{
|
|
57628
|
+
title: "Recording engine (simple)",
|
|
57629
|
+
type: "string",
|
|
57630
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57631
|
+
enum: [
|
|
57632
|
+
"browser",
|
|
57633
|
+
"ffmpeg"
|
|
57634
|
+
]
|
|
57635
|
+
},
|
|
57636
|
+
{
|
|
57637
|
+
title: "Recording engine (detailed)",
|
|
57638
|
+
type: "object",
|
|
57639
|
+
additionalProperties: false,
|
|
57640
|
+
required: [
|
|
57641
|
+
"name"
|
|
57642
|
+
],
|
|
57643
|
+
properties: {
|
|
57644
|
+
name: {
|
|
57645
|
+
type: "string",
|
|
57646
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57647
|
+
enum: [
|
|
57648
|
+
"browser",
|
|
57649
|
+
"ffmpeg"
|
|
57650
|
+
]
|
|
57651
|
+
},
|
|
57652
|
+
target: {
|
|
57653
|
+
type: "string",
|
|
57654
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
57655
|
+
enum: [
|
|
57656
|
+
"display",
|
|
57657
|
+
"window",
|
|
57658
|
+
"viewport"
|
|
57659
|
+
],
|
|
57660
|
+
default: "display"
|
|
57661
|
+
},
|
|
57662
|
+
fps: {
|
|
57663
|
+
type: "integer",
|
|
57664
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
57665
|
+
default: 30,
|
|
57666
|
+
minimum: 1
|
|
57667
|
+
}
|
|
57668
|
+
}
|
|
57669
|
+
}
|
|
57670
|
+
]
|
|
56619
57671
|
}
|
|
56620
57672
|
},
|
|
56621
57673
|
title: "Record (detailed)"
|
|
57674
|
+
},
|
|
57675
|
+
engine: {
|
|
57676
|
+
title: "Recording engine",
|
|
57677
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
57678
|
+
anyOf: [
|
|
57679
|
+
{
|
|
57680
|
+
title: "Recording engine (simple)",
|
|
57681
|
+
type: "string",
|
|
57682
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57683
|
+
enum: [
|
|
57684
|
+
"browser",
|
|
57685
|
+
"ffmpeg"
|
|
57686
|
+
]
|
|
57687
|
+
},
|
|
57688
|
+
{
|
|
57689
|
+
title: "Recording engine (detailed)",
|
|
57690
|
+
type: "object",
|
|
57691
|
+
additionalProperties: false,
|
|
57692
|
+
required: [
|
|
57693
|
+
"name"
|
|
57694
|
+
],
|
|
57695
|
+
properties: {
|
|
57696
|
+
name: {
|
|
57697
|
+
type: "string",
|
|
57698
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
57699
|
+
enum: [
|
|
57700
|
+
"browser",
|
|
57701
|
+
"ffmpeg"
|
|
57702
|
+
]
|
|
57703
|
+
},
|
|
57704
|
+
target: {
|
|
57705
|
+
type: "string",
|
|
57706
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
57707
|
+
enum: [
|
|
57708
|
+
"display",
|
|
57709
|
+
"window",
|
|
57710
|
+
"viewport"
|
|
57711
|
+
],
|
|
57712
|
+
default: "display"
|
|
57713
|
+
},
|
|
57714
|
+
fps: {
|
|
57715
|
+
type: "integer",
|
|
57716
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
57717
|
+
default: 30,
|
|
57718
|
+
minimum: 1
|
|
57719
|
+
}
|
|
57720
|
+
}
|
|
57721
|
+
}
|
|
57722
|
+
]
|
|
56622
57723
|
}
|
|
56623
57724
|
}
|
|
56624
57725
|
},
|
|
@@ -56629,6 +57730,18 @@ var schemas_default = {
|
|
|
56629
57730
|
path: "results.mp4",
|
|
56630
57731
|
directory: "static/media",
|
|
56631
57732
|
overwrite: "true"
|
|
57733
|
+
},
|
|
57734
|
+
{
|
|
57735
|
+
path: "results.mp4",
|
|
57736
|
+
engine: "ffmpeg"
|
|
57737
|
+
},
|
|
57738
|
+
{
|
|
57739
|
+
path: "results.mp4",
|
|
57740
|
+
engine: {
|
|
57741
|
+
name: "ffmpeg",
|
|
57742
|
+
target: "window",
|
|
57743
|
+
fps: 60
|
|
57744
|
+
}
|
|
56632
57745
|
}
|
|
56633
57746
|
]
|
|
56634
57747
|
}
|
|
@@ -66577,7 +67690,7 @@ var schemas_default = {
|
|
|
66577
67690
|
record: {
|
|
66578
67691
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
66579
67692
|
title: "record",
|
|
66580
|
-
description: "Start recording
|
|
67693
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
66581
67694
|
anyOf: [
|
|
66582
67695
|
{
|
|
66583
67696
|
title: "Record (simple)",
|
|
@@ -66613,6 +67726,55 @@ var schemas_default = {
|
|
|
66613
67726
|
"true",
|
|
66614
67727
|
"false"
|
|
66615
67728
|
]
|
|
67729
|
+
},
|
|
67730
|
+
engine: {
|
|
67731
|
+
title: "Recording engine",
|
|
67732
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
67733
|
+
anyOf: [
|
|
67734
|
+
{
|
|
67735
|
+
title: "Recording engine (simple)",
|
|
67736
|
+
type: "string",
|
|
67737
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67738
|
+
enum: [
|
|
67739
|
+
"browser",
|
|
67740
|
+
"ffmpeg"
|
|
67741
|
+
]
|
|
67742
|
+
},
|
|
67743
|
+
{
|
|
67744
|
+
title: "Recording engine (detailed)",
|
|
67745
|
+
type: "object",
|
|
67746
|
+
additionalProperties: false,
|
|
67747
|
+
required: [
|
|
67748
|
+
"name"
|
|
67749
|
+
],
|
|
67750
|
+
properties: {
|
|
67751
|
+
name: {
|
|
67752
|
+
type: "string",
|
|
67753
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67754
|
+
enum: [
|
|
67755
|
+
"browser",
|
|
67756
|
+
"ffmpeg"
|
|
67757
|
+
]
|
|
67758
|
+
},
|
|
67759
|
+
target: {
|
|
67760
|
+
type: "string",
|
|
67761
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
67762
|
+
enum: [
|
|
67763
|
+
"display",
|
|
67764
|
+
"window",
|
|
67765
|
+
"viewport"
|
|
67766
|
+
],
|
|
67767
|
+
default: "display"
|
|
67768
|
+
},
|
|
67769
|
+
fps: {
|
|
67770
|
+
type: "integer",
|
|
67771
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
67772
|
+
default: 30,
|
|
67773
|
+
minimum: 1
|
|
67774
|
+
}
|
|
67775
|
+
}
|
|
67776
|
+
}
|
|
67777
|
+
]
|
|
66616
67778
|
}
|
|
66617
67779
|
},
|
|
66618
67780
|
title: "Record (detailed)"
|
|
@@ -66620,7 +67782,7 @@ var schemas_default = {
|
|
|
66620
67782
|
{
|
|
66621
67783
|
type: "boolean",
|
|
66622
67784
|
title: "Record (boolean)",
|
|
66623
|
-
description: "If `true`,
|
|
67785
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
66624
67786
|
}
|
|
66625
67787
|
],
|
|
66626
67788
|
components: {
|
|
@@ -66659,9 +67821,107 @@ var schemas_default = {
|
|
|
66659
67821
|
"true",
|
|
66660
67822
|
"false"
|
|
66661
67823
|
]
|
|
67824
|
+
},
|
|
67825
|
+
engine: {
|
|
67826
|
+
title: "Recording engine",
|
|
67827
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
67828
|
+
anyOf: [
|
|
67829
|
+
{
|
|
67830
|
+
title: "Recording engine (simple)",
|
|
67831
|
+
type: "string",
|
|
67832
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67833
|
+
enum: [
|
|
67834
|
+
"browser",
|
|
67835
|
+
"ffmpeg"
|
|
67836
|
+
]
|
|
67837
|
+
},
|
|
67838
|
+
{
|
|
67839
|
+
title: "Recording engine (detailed)",
|
|
67840
|
+
type: "object",
|
|
67841
|
+
additionalProperties: false,
|
|
67842
|
+
required: [
|
|
67843
|
+
"name"
|
|
67844
|
+
],
|
|
67845
|
+
properties: {
|
|
67846
|
+
name: {
|
|
67847
|
+
type: "string",
|
|
67848
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67849
|
+
enum: [
|
|
67850
|
+
"browser",
|
|
67851
|
+
"ffmpeg"
|
|
67852
|
+
]
|
|
67853
|
+
},
|
|
67854
|
+
target: {
|
|
67855
|
+
type: "string",
|
|
67856
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
67857
|
+
enum: [
|
|
67858
|
+
"display",
|
|
67859
|
+
"window",
|
|
67860
|
+
"viewport"
|
|
67861
|
+
],
|
|
67862
|
+
default: "display"
|
|
67863
|
+
},
|
|
67864
|
+
fps: {
|
|
67865
|
+
type: "integer",
|
|
67866
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
67867
|
+
default: 30,
|
|
67868
|
+
minimum: 1
|
|
67869
|
+
}
|
|
67870
|
+
}
|
|
67871
|
+
}
|
|
67872
|
+
]
|
|
66662
67873
|
}
|
|
66663
67874
|
},
|
|
66664
67875
|
title: "Record (detailed)"
|
|
67876
|
+
},
|
|
67877
|
+
engine: {
|
|
67878
|
+
title: "Recording engine",
|
|
67879
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
67880
|
+
anyOf: [
|
|
67881
|
+
{
|
|
67882
|
+
title: "Recording engine (simple)",
|
|
67883
|
+
type: "string",
|
|
67884
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67885
|
+
enum: [
|
|
67886
|
+
"browser",
|
|
67887
|
+
"ffmpeg"
|
|
67888
|
+
]
|
|
67889
|
+
},
|
|
67890
|
+
{
|
|
67891
|
+
title: "Recording engine (detailed)",
|
|
67892
|
+
type: "object",
|
|
67893
|
+
additionalProperties: false,
|
|
67894
|
+
required: [
|
|
67895
|
+
"name"
|
|
67896
|
+
],
|
|
67897
|
+
properties: {
|
|
67898
|
+
name: {
|
|
67899
|
+
type: "string",
|
|
67900
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
67901
|
+
enum: [
|
|
67902
|
+
"browser",
|
|
67903
|
+
"ffmpeg"
|
|
67904
|
+
]
|
|
67905
|
+
},
|
|
67906
|
+
target: {
|
|
67907
|
+
type: "string",
|
|
67908
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
67909
|
+
enum: [
|
|
67910
|
+
"display",
|
|
67911
|
+
"window",
|
|
67912
|
+
"viewport"
|
|
67913
|
+
],
|
|
67914
|
+
default: "display"
|
|
67915
|
+
},
|
|
67916
|
+
fps: {
|
|
67917
|
+
type: "integer",
|
|
67918
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
67919
|
+
default: 30,
|
|
67920
|
+
minimum: 1
|
|
67921
|
+
}
|
|
67922
|
+
}
|
|
67923
|
+
}
|
|
67924
|
+
]
|
|
66665
67925
|
}
|
|
66666
67926
|
}
|
|
66667
67927
|
},
|
|
@@ -66672,6 +67932,18 @@ var schemas_default = {
|
|
|
66672
67932
|
path: "results.mp4",
|
|
66673
67933
|
directory: "static/media",
|
|
66674
67934
|
overwrite: "true"
|
|
67935
|
+
},
|
|
67936
|
+
{
|
|
67937
|
+
path: "results.mp4",
|
|
67938
|
+
engine: "ffmpeg"
|
|
67939
|
+
},
|
|
67940
|
+
{
|
|
67941
|
+
path: "results.mp4",
|
|
67942
|
+
engine: {
|
|
67943
|
+
name: "ffmpeg",
|
|
67944
|
+
target: "window",
|
|
67945
|
+
fps: 60
|
|
67946
|
+
}
|
|
66675
67947
|
}
|
|
66676
67948
|
]
|
|
66677
67949
|
}
|
|
@@ -74892,7 +76164,7 @@ var schemas_default = {
|
|
|
74892
76164
|
record: {
|
|
74893
76165
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
74894
76166
|
title: "record",
|
|
74895
|
-
description: "Start recording
|
|
76167
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
74896
76168
|
anyOf: [
|
|
74897
76169
|
{
|
|
74898
76170
|
title: "Record (simple)",
|
|
@@ -74928,6 +76200,55 @@ var schemas_default = {
|
|
|
74928
76200
|
"true",
|
|
74929
76201
|
"false"
|
|
74930
76202
|
]
|
|
76203
|
+
},
|
|
76204
|
+
engine: {
|
|
76205
|
+
title: "Recording engine",
|
|
76206
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
76207
|
+
anyOf: [
|
|
76208
|
+
{
|
|
76209
|
+
title: "Recording engine (simple)",
|
|
76210
|
+
type: "string",
|
|
76211
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76212
|
+
enum: [
|
|
76213
|
+
"browser",
|
|
76214
|
+
"ffmpeg"
|
|
76215
|
+
]
|
|
76216
|
+
},
|
|
76217
|
+
{
|
|
76218
|
+
title: "Recording engine (detailed)",
|
|
76219
|
+
type: "object",
|
|
76220
|
+
additionalProperties: false,
|
|
76221
|
+
required: [
|
|
76222
|
+
"name"
|
|
76223
|
+
],
|
|
76224
|
+
properties: {
|
|
76225
|
+
name: {
|
|
76226
|
+
type: "string",
|
|
76227
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76228
|
+
enum: [
|
|
76229
|
+
"browser",
|
|
76230
|
+
"ffmpeg"
|
|
76231
|
+
]
|
|
76232
|
+
},
|
|
76233
|
+
target: {
|
|
76234
|
+
type: "string",
|
|
76235
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
76236
|
+
enum: [
|
|
76237
|
+
"display",
|
|
76238
|
+
"window",
|
|
76239
|
+
"viewport"
|
|
76240
|
+
],
|
|
76241
|
+
default: "display"
|
|
76242
|
+
},
|
|
76243
|
+
fps: {
|
|
76244
|
+
type: "integer",
|
|
76245
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
76246
|
+
default: 30,
|
|
76247
|
+
minimum: 1
|
|
76248
|
+
}
|
|
76249
|
+
}
|
|
76250
|
+
}
|
|
76251
|
+
]
|
|
74931
76252
|
}
|
|
74932
76253
|
},
|
|
74933
76254
|
title: "Record (detailed)"
|
|
@@ -74935,7 +76256,7 @@ var schemas_default = {
|
|
|
74935
76256
|
{
|
|
74936
76257
|
type: "boolean",
|
|
74937
76258
|
title: "Record (boolean)",
|
|
74938
|
-
description: "If `true`,
|
|
76259
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
74939
76260
|
}
|
|
74940
76261
|
],
|
|
74941
76262
|
components: {
|
|
@@ -74974,9 +76295,107 @@ var schemas_default = {
|
|
|
74974
76295
|
"true",
|
|
74975
76296
|
"false"
|
|
74976
76297
|
]
|
|
76298
|
+
},
|
|
76299
|
+
engine: {
|
|
76300
|
+
title: "Recording engine",
|
|
76301
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
76302
|
+
anyOf: [
|
|
76303
|
+
{
|
|
76304
|
+
title: "Recording engine (simple)",
|
|
76305
|
+
type: "string",
|
|
76306
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76307
|
+
enum: [
|
|
76308
|
+
"browser",
|
|
76309
|
+
"ffmpeg"
|
|
76310
|
+
]
|
|
76311
|
+
},
|
|
76312
|
+
{
|
|
76313
|
+
title: "Recording engine (detailed)",
|
|
76314
|
+
type: "object",
|
|
76315
|
+
additionalProperties: false,
|
|
76316
|
+
required: [
|
|
76317
|
+
"name"
|
|
76318
|
+
],
|
|
76319
|
+
properties: {
|
|
76320
|
+
name: {
|
|
76321
|
+
type: "string",
|
|
76322
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76323
|
+
enum: [
|
|
76324
|
+
"browser",
|
|
76325
|
+
"ffmpeg"
|
|
76326
|
+
]
|
|
76327
|
+
},
|
|
76328
|
+
target: {
|
|
76329
|
+
type: "string",
|
|
76330
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
76331
|
+
enum: [
|
|
76332
|
+
"display",
|
|
76333
|
+
"window",
|
|
76334
|
+
"viewport"
|
|
76335
|
+
],
|
|
76336
|
+
default: "display"
|
|
76337
|
+
},
|
|
76338
|
+
fps: {
|
|
76339
|
+
type: "integer",
|
|
76340
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
76341
|
+
default: 30,
|
|
76342
|
+
minimum: 1
|
|
76343
|
+
}
|
|
76344
|
+
}
|
|
76345
|
+
}
|
|
76346
|
+
]
|
|
74977
76347
|
}
|
|
74978
76348
|
},
|
|
74979
76349
|
title: "Record (detailed)"
|
|
76350
|
+
},
|
|
76351
|
+
engine: {
|
|
76352
|
+
title: "Recording engine",
|
|
76353
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
76354
|
+
anyOf: [
|
|
76355
|
+
{
|
|
76356
|
+
title: "Recording engine (simple)",
|
|
76357
|
+
type: "string",
|
|
76358
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76359
|
+
enum: [
|
|
76360
|
+
"browser",
|
|
76361
|
+
"ffmpeg"
|
|
76362
|
+
]
|
|
76363
|
+
},
|
|
76364
|
+
{
|
|
76365
|
+
title: "Recording engine (detailed)",
|
|
76366
|
+
type: "object",
|
|
76367
|
+
additionalProperties: false,
|
|
76368
|
+
required: [
|
|
76369
|
+
"name"
|
|
76370
|
+
],
|
|
76371
|
+
properties: {
|
|
76372
|
+
name: {
|
|
76373
|
+
type: "string",
|
|
76374
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
76375
|
+
enum: [
|
|
76376
|
+
"browser",
|
|
76377
|
+
"ffmpeg"
|
|
76378
|
+
]
|
|
76379
|
+
},
|
|
76380
|
+
target: {
|
|
76381
|
+
type: "string",
|
|
76382
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
76383
|
+
enum: [
|
|
76384
|
+
"display",
|
|
76385
|
+
"window",
|
|
76386
|
+
"viewport"
|
|
76387
|
+
],
|
|
76388
|
+
default: "display"
|
|
76389
|
+
},
|
|
76390
|
+
fps: {
|
|
76391
|
+
type: "integer",
|
|
76392
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
76393
|
+
default: 30,
|
|
76394
|
+
minimum: 1
|
|
76395
|
+
}
|
|
76396
|
+
}
|
|
76397
|
+
}
|
|
76398
|
+
]
|
|
74980
76399
|
}
|
|
74981
76400
|
}
|
|
74982
76401
|
},
|
|
@@ -74987,6 +76406,18 @@ var schemas_default = {
|
|
|
74987
76406
|
path: "results.mp4",
|
|
74988
76407
|
directory: "static/media",
|
|
74989
76408
|
overwrite: "true"
|
|
76409
|
+
},
|
|
76410
|
+
{
|
|
76411
|
+
path: "results.mp4",
|
|
76412
|
+
engine: "ffmpeg"
|
|
76413
|
+
},
|
|
76414
|
+
{
|
|
76415
|
+
path: "results.mp4",
|
|
76416
|
+
engine: {
|
|
76417
|
+
name: "ffmpeg",
|
|
76418
|
+
target: "window",
|
|
76419
|
+
fps: 60
|
|
76420
|
+
}
|
|
74990
76421
|
}
|
|
74991
76422
|
]
|
|
74992
76423
|
}
|
|
@@ -86313,7 +87744,7 @@ var schemas_default = {
|
|
|
86313
87744
|
record: {
|
|
86314
87745
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
86315
87746
|
title: "record",
|
|
86316
|
-
description: "Start recording
|
|
87747
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
86317
87748
|
anyOf: [
|
|
86318
87749
|
{
|
|
86319
87750
|
title: "Record (simple)",
|
|
@@ -86349,6 +87780,55 @@ var schemas_default = {
|
|
|
86349
87780
|
"true",
|
|
86350
87781
|
"false"
|
|
86351
87782
|
]
|
|
87783
|
+
},
|
|
87784
|
+
engine: {
|
|
87785
|
+
title: "Recording engine",
|
|
87786
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
87787
|
+
anyOf: [
|
|
87788
|
+
{
|
|
87789
|
+
title: "Recording engine (simple)",
|
|
87790
|
+
type: "string",
|
|
87791
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87792
|
+
enum: [
|
|
87793
|
+
"browser",
|
|
87794
|
+
"ffmpeg"
|
|
87795
|
+
]
|
|
87796
|
+
},
|
|
87797
|
+
{
|
|
87798
|
+
title: "Recording engine (detailed)",
|
|
87799
|
+
type: "object",
|
|
87800
|
+
additionalProperties: false,
|
|
87801
|
+
required: [
|
|
87802
|
+
"name"
|
|
87803
|
+
],
|
|
87804
|
+
properties: {
|
|
87805
|
+
name: {
|
|
87806
|
+
type: "string",
|
|
87807
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87808
|
+
enum: [
|
|
87809
|
+
"browser",
|
|
87810
|
+
"ffmpeg"
|
|
87811
|
+
]
|
|
87812
|
+
},
|
|
87813
|
+
target: {
|
|
87814
|
+
type: "string",
|
|
87815
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
87816
|
+
enum: [
|
|
87817
|
+
"display",
|
|
87818
|
+
"window",
|
|
87819
|
+
"viewport"
|
|
87820
|
+
],
|
|
87821
|
+
default: "display"
|
|
87822
|
+
},
|
|
87823
|
+
fps: {
|
|
87824
|
+
type: "integer",
|
|
87825
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
87826
|
+
default: 30,
|
|
87827
|
+
minimum: 1
|
|
87828
|
+
}
|
|
87829
|
+
}
|
|
87830
|
+
}
|
|
87831
|
+
]
|
|
86352
87832
|
}
|
|
86353
87833
|
},
|
|
86354
87834
|
title: "Record (detailed)"
|
|
@@ -86356,7 +87836,7 @@ var schemas_default = {
|
|
|
86356
87836
|
{
|
|
86357
87837
|
type: "boolean",
|
|
86358
87838
|
title: "Record (boolean)",
|
|
86359
|
-
description: "If `true`,
|
|
87839
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
86360
87840
|
}
|
|
86361
87841
|
],
|
|
86362
87842
|
components: {
|
|
@@ -86395,9 +87875,107 @@ var schemas_default = {
|
|
|
86395
87875
|
"true",
|
|
86396
87876
|
"false"
|
|
86397
87877
|
]
|
|
87878
|
+
},
|
|
87879
|
+
engine: {
|
|
87880
|
+
title: "Recording engine",
|
|
87881
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
87882
|
+
anyOf: [
|
|
87883
|
+
{
|
|
87884
|
+
title: "Recording engine (simple)",
|
|
87885
|
+
type: "string",
|
|
87886
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87887
|
+
enum: [
|
|
87888
|
+
"browser",
|
|
87889
|
+
"ffmpeg"
|
|
87890
|
+
]
|
|
87891
|
+
},
|
|
87892
|
+
{
|
|
87893
|
+
title: "Recording engine (detailed)",
|
|
87894
|
+
type: "object",
|
|
87895
|
+
additionalProperties: false,
|
|
87896
|
+
required: [
|
|
87897
|
+
"name"
|
|
87898
|
+
],
|
|
87899
|
+
properties: {
|
|
87900
|
+
name: {
|
|
87901
|
+
type: "string",
|
|
87902
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87903
|
+
enum: [
|
|
87904
|
+
"browser",
|
|
87905
|
+
"ffmpeg"
|
|
87906
|
+
]
|
|
87907
|
+
},
|
|
87908
|
+
target: {
|
|
87909
|
+
type: "string",
|
|
87910
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
87911
|
+
enum: [
|
|
87912
|
+
"display",
|
|
87913
|
+
"window",
|
|
87914
|
+
"viewport"
|
|
87915
|
+
],
|
|
87916
|
+
default: "display"
|
|
87917
|
+
},
|
|
87918
|
+
fps: {
|
|
87919
|
+
type: "integer",
|
|
87920
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
87921
|
+
default: 30,
|
|
87922
|
+
minimum: 1
|
|
87923
|
+
}
|
|
87924
|
+
}
|
|
87925
|
+
}
|
|
87926
|
+
]
|
|
86398
87927
|
}
|
|
86399
87928
|
},
|
|
86400
87929
|
title: "Record (detailed)"
|
|
87930
|
+
},
|
|
87931
|
+
engine: {
|
|
87932
|
+
title: "Recording engine",
|
|
87933
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
87934
|
+
anyOf: [
|
|
87935
|
+
{
|
|
87936
|
+
title: "Recording engine (simple)",
|
|
87937
|
+
type: "string",
|
|
87938
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87939
|
+
enum: [
|
|
87940
|
+
"browser",
|
|
87941
|
+
"ffmpeg"
|
|
87942
|
+
]
|
|
87943
|
+
},
|
|
87944
|
+
{
|
|
87945
|
+
title: "Recording engine (detailed)",
|
|
87946
|
+
type: "object",
|
|
87947
|
+
additionalProperties: false,
|
|
87948
|
+
required: [
|
|
87949
|
+
"name"
|
|
87950
|
+
],
|
|
87951
|
+
properties: {
|
|
87952
|
+
name: {
|
|
87953
|
+
type: "string",
|
|
87954
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
87955
|
+
enum: [
|
|
87956
|
+
"browser",
|
|
87957
|
+
"ffmpeg"
|
|
87958
|
+
]
|
|
87959
|
+
},
|
|
87960
|
+
target: {
|
|
87961
|
+
type: "string",
|
|
87962
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
87963
|
+
enum: [
|
|
87964
|
+
"display",
|
|
87965
|
+
"window",
|
|
87966
|
+
"viewport"
|
|
87967
|
+
],
|
|
87968
|
+
default: "display"
|
|
87969
|
+
},
|
|
87970
|
+
fps: {
|
|
87971
|
+
type: "integer",
|
|
87972
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
87973
|
+
default: 30,
|
|
87974
|
+
minimum: 1
|
|
87975
|
+
}
|
|
87976
|
+
}
|
|
87977
|
+
}
|
|
87978
|
+
]
|
|
86401
87979
|
}
|
|
86402
87980
|
}
|
|
86403
87981
|
},
|
|
@@ -86408,6 +87986,18 @@ var schemas_default = {
|
|
|
86408
87986
|
path: "results.mp4",
|
|
86409
87987
|
directory: "static/media",
|
|
86410
87988
|
overwrite: "true"
|
|
87989
|
+
},
|
|
87990
|
+
{
|
|
87991
|
+
path: "results.mp4",
|
|
87992
|
+
engine: "ffmpeg"
|
|
87993
|
+
},
|
|
87994
|
+
{
|
|
87995
|
+
path: "results.mp4",
|
|
87996
|
+
engine: {
|
|
87997
|
+
name: "ffmpeg",
|
|
87998
|
+
target: "window",
|
|
87999
|
+
fps: 60
|
|
88000
|
+
}
|
|
86411
88001
|
}
|
|
86412
88002
|
]
|
|
86413
88003
|
}
|
|
@@ -94628,7 +96218,7 @@ var schemas_default = {
|
|
|
94628
96218
|
record: {
|
|
94629
96219
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
94630
96220
|
title: "record",
|
|
94631
|
-
description: "Start recording
|
|
96221
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
94632
96222
|
anyOf: [
|
|
94633
96223
|
{
|
|
94634
96224
|
title: "Record (simple)",
|
|
@@ -94664,6 +96254,55 @@ var schemas_default = {
|
|
|
94664
96254
|
"true",
|
|
94665
96255
|
"false"
|
|
94666
96256
|
]
|
|
96257
|
+
},
|
|
96258
|
+
engine: {
|
|
96259
|
+
title: "Recording engine",
|
|
96260
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
96261
|
+
anyOf: [
|
|
96262
|
+
{
|
|
96263
|
+
title: "Recording engine (simple)",
|
|
96264
|
+
type: "string",
|
|
96265
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96266
|
+
enum: [
|
|
96267
|
+
"browser",
|
|
96268
|
+
"ffmpeg"
|
|
96269
|
+
]
|
|
96270
|
+
},
|
|
96271
|
+
{
|
|
96272
|
+
title: "Recording engine (detailed)",
|
|
96273
|
+
type: "object",
|
|
96274
|
+
additionalProperties: false,
|
|
96275
|
+
required: [
|
|
96276
|
+
"name"
|
|
96277
|
+
],
|
|
96278
|
+
properties: {
|
|
96279
|
+
name: {
|
|
96280
|
+
type: "string",
|
|
96281
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96282
|
+
enum: [
|
|
96283
|
+
"browser",
|
|
96284
|
+
"ffmpeg"
|
|
96285
|
+
]
|
|
96286
|
+
},
|
|
96287
|
+
target: {
|
|
96288
|
+
type: "string",
|
|
96289
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
96290
|
+
enum: [
|
|
96291
|
+
"display",
|
|
96292
|
+
"window",
|
|
96293
|
+
"viewport"
|
|
96294
|
+
],
|
|
96295
|
+
default: "display"
|
|
96296
|
+
},
|
|
96297
|
+
fps: {
|
|
96298
|
+
type: "integer",
|
|
96299
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
96300
|
+
default: 30,
|
|
96301
|
+
minimum: 1
|
|
96302
|
+
}
|
|
96303
|
+
}
|
|
96304
|
+
}
|
|
96305
|
+
]
|
|
94667
96306
|
}
|
|
94668
96307
|
},
|
|
94669
96308
|
title: "Record (detailed)"
|
|
@@ -94671,7 +96310,7 @@ var schemas_default = {
|
|
|
94671
96310
|
{
|
|
94672
96311
|
type: "boolean",
|
|
94673
96312
|
title: "Record (boolean)",
|
|
94674
|
-
description: "If `true`,
|
|
96313
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
94675
96314
|
}
|
|
94676
96315
|
],
|
|
94677
96316
|
components: {
|
|
@@ -94710,9 +96349,107 @@ var schemas_default = {
|
|
|
94710
96349
|
"true",
|
|
94711
96350
|
"false"
|
|
94712
96351
|
]
|
|
96352
|
+
},
|
|
96353
|
+
engine: {
|
|
96354
|
+
title: "Recording engine",
|
|
96355
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
96356
|
+
anyOf: [
|
|
96357
|
+
{
|
|
96358
|
+
title: "Recording engine (simple)",
|
|
96359
|
+
type: "string",
|
|
96360
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96361
|
+
enum: [
|
|
96362
|
+
"browser",
|
|
96363
|
+
"ffmpeg"
|
|
96364
|
+
]
|
|
96365
|
+
},
|
|
96366
|
+
{
|
|
96367
|
+
title: "Recording engine (detailed)",
|
|
96368
|
+
type: "object",
|
|
96369
|
+
additionalProperties: false,
|
|
96370
|
+
required: [
|
|
96371
|
+
"name"
|
|
96372
|
+
],
|
|
96373
|
+
properties: {
|
|
96374
|
+
name: {
|
|
96375
|
+
type: "string",
|
|
96376
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96377
|
+
enum: [
|
|
96378
|
+
"browser",
|
|
96379
|
+
"ffmpeg"
|
|
96380
|
+
]
|
|
96381
|
+
},
|
|
96382
|
+
target: {
|
|
96383
|
+
type: "string",
|
|
96384
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
96385
|
+
enum: [
|
|
96386
|
+
"display",
|
|
96387
|
+
"window",
|
|
96388
|
+
"viewport"
|
|
96389
|
+
],
|
|
96390
|
+
default: "display"
|
|
96391
|
+
},
|
|
96392
|
+
fps: {
|
|
96393
|
+
type: "integer",
|
|
96394
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
96395
|
+
default: 30,
|
|
96396
|
+
minimum: 1
|
|
96397
|
+
}
|
|
96398
|
+
}
|
|
96399
|
+
}
|
|
96400
|
+
]
|
|
94713
96401
|
}
|
|
94714
96402
|
},
|
|
94715
96403
|
title: "Record (detailed)"
|
|
96404
|
+
},
|
|
96405
|
+
engine: {
|
|
96406
|
+
title: "Recording engine",
|
|
96407
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
96408
|
+
anyOf: [
|
|
96409
|
+
{
|
|
96410
|
+
title: "Recording engine (simple)",
|
|
96411
|
+
type: "string",
|
|
96412
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96413
|
+
enum: [
|
|
96414
|
+
"browser",
|
|
96415
|
+
"ffmpeg"
|
|
96416
|
+
]
|
|
96417
|
+
},
|
|
96418
|
+
{
|
|
96419
|
+
title: "Recording engine (detailed)",
|
|
96420
|
+
type: "object",
|
|
96421
|
+
additionalProperties: false,
|
|
96422
|
+
required: [
|
|
96423
|
+
"name"
|
|
96424
|
+
],
|
|
96425
|
+
properties: {
|
|
96426
|
+
name: {
|
|
96427
|
+
type: "string",
|
|
96428
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
96429
|
+
enum: [
|
|
96430
|
+
"browser",
|
|
96431
|
+
"ffmpeg"
|
|
96432
|
+
]
|
|
96433
|
+
},
|
|
96434
|
+
target: {
|
|
96435
|
+
type: "string",
|
|
96436
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
96437
|
+
enum: [
|
|
96438
|
+
"display",
|
|
96439
|
+
"window",
|
|
96440
|
+
"viewport"
|
|
96441
|
+
],
|
|
96442
|
+
default: "display"
|
|
96443
|
+
},
|
|
96444
|
+
fps: {
|
|
96445
|
+
type: "integer",
|
|
96446
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
96447
|
+
default: 30,
|
|
96448
|
+
minimum: 1
|
|
96449
|
+
}
|
|
96450
|
+
}
|
|
96451
|
+
}
|
|
96452
|
+
]
|
|
94716
96453
|
}
|
|
94717
96454
|
}
|
|
94718
96455
|
},
|
|
@@ -94723,6 +96460,18 @@ var schemas_default = {
|
|
|
94723
96460
|
path: "results.mp4",
|
|
94724
96461
|
directory: "static/media",
|
|
94725
96462
|
overwrite: "true"
|
|
96463
|
+
},
|
|
96464
|
+
{
|
|
96465
|
+
path: "results.mp4",
|
|
96466
|
+
engine: "ffmpeg"
|
|
96467
|
+
},
|
|
96468
|
+
{
|
|
96469
|
+
path: "results.mp4",
|
|
96470
|
+
engine: {
|
|
96471
|
+
name: "ffmpeg",
|
|
96472
|
+
target: "window",
|
|
96473
|
+
fps: 60
|
|
96474
|
+
}
|
|
94726
96475
|
}
|
|
94727
96476
|
]
|
|
94728
96477
|
}
|
|
@@ -103223,7 +104972,7 @@ var schemas_default = {
|
|
|
103223
104972
|
record: {
|
|
103224
104973
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
103225
104974
|
title: "record",
|
|
103226
|
-
description: "Start recording
|
|
104975
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
103227
104976
|
anyOf: [
|
|
103228
104977
|
{
|
|
103229
104978
|
title: "Record (simple)",
|
|
@@ -103259,6 +105008,55 @@ var schemas_default = {
|
|
|
103259
105008
|
"true",
|
|
103260
105009
|
"false"
|
|
103261
105010
|
]
|
|
105011
|
+
},
|
|
105012
|
+
engine: {
|
|
105013
|
+
title: "Recording engine",
|
|
105014
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
105015
|
+
anyOf: [
|
|
105016
|
+
{
|
|
105017
|
+
title: "Recording engine (simple)",
|
|
105018
|
+
type: "string",
|
|
105019
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105020
|
+
enum: [
|
|
105021
|
+
"browser",
|
|
105022
|
+
"ffmpeg"
|
|
105023
|
+
]
|
|
105024
|
+
},
|
|
105025
|
+
{
|
|
105026
|
+
title: "Recording engine (detailed)",
|
|
105027
|
+
type: "object",
|
|
105028
|
+
additionalProperties: false,
|
|
105029
|
+
required: [
|
|
105030
|
+
"name"
|
|
105031
|
+
],
|
|
105032
|
+
properties: {
|
|
105033
|
+
name: {
|
|
105034
|
+
type: "string",
|
|
105035
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105036
|
+
enum: [
|
|
105037
|
+
"browser",
|
|
105038
|
+
"ffmpeg"
|
|
105039
|
+
]
|
|
105040
|
+
},
|
|
105041
|
+
target: {
|
|
105042
|
+
type: "string",
|
|
105043
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
105044
|
+
enum: [
|
|
105045
|
+
"display",
|
|
105046
|
+
"window",
|
|
105047
|
+
"viewport"
|
|
105048
|
+
],
|
|
105049
|
+
default: "display"
|
|
105050
|
+
},
|
|
105051
|
+
fps: {
|
|
105052
|
+
type: "integer",
|
|
105053
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
105054
|
+
default: 30,
|
|
105055
|
+
minimum: 1
|
|
105056
|
+
}
|
|
105057
|
+
}
|
|
105058
|
+
}
|
|
105059
|
+
]
|
|
103262
105060
|
}
|
|
103263
105061
|
},
|
|
103264
105062
|
title: "Record (detailed)"
|
|
@@ -103266,7 +105064,7 @@ var schemas_default = {
|
|
|
103266
105064
|
{
|
|
103267
105065
|
type: "boolean",
|
|
103268
105066
|
title: "Record (boolean)",
|
|
103269
|
-
description: "If `true`,
|
|
105067
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
103270
105068
|
}
|
|
103271
105069
|
],
|
|
103272
105070
|
components: {
|
|
@@ -103305,9 +105103,107 @@ var schemas_default = {
|
|
|
103305
105103
|
"true",
|
|
103306
105104
|
"false"
|
|
103307
105105
|
]
|
|
105106
|
+
},
|
|
105107
|
+
engine: {
|
|
105108
|
+
title: "Recording engine",
|
|
105109
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
105110
|
+
anyOf: [
|
|
105111
|
+
{
|
|
105112
|
+
title: "Recording engine (simple)",
|
|
105113
|
+
type: "string",
|
|
105114
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105115
|
+
enum: [
|
|
105116
|
+
"browser",
|
|
105117
|
+
"ffmpeg"
|
|
105118
|
+
]
|
|
105119
|
+
},
|
|
105120
|
+
{
|
|
105121
|
+
title: "Recording engine (detailed)",
|
|
105122
|
+
type: "object",
|
|
105123
|
+
additionalProperties: false,
|
|
105124
|
+
required: [
|
|
105125
|
+
"name"
|
|
105126
|
+
],
|
|
105127
|
+
properties: {
|
|
105128
|
+
name: {
|
|
105129
|
+
type: "string",
|
|
105130
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105131
|
+
enum: [
|
|
105132
|
+
"browser",
|
|
105133
|
+
"ffmpeg"
|
|
105134
|
+
]
|
|
105135
|
+
},
|
|
105136
|
+
target: {
|
|
105137
|
+
type: "string",
|
|
105138
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
105139
|
+
enum: [
|
|
105140
|
+
"display",
|
|
105141
|
+
"window",
|
|
105142
|
+
"viewport"
|
|
105143
|
+
],
|
|
105144
|
+
default: "display"
|
|
105145
|
+
},
|
|
105146
|
+
fps: {
|
|
105147
|
+
type: "integer",
|
|
105148
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
105149
|
+
default: 30,
|
|
105150
|
+
minimum: 1
|
|
105151
|
+
}
|
|
105152
|
+
}
|
|
105153
|
+
}
|
|
105154
|
+
]
|
|
103308
105155
|
}
|
|
103309
105156
|
},
|
|
103310
105157
|
title: "Record (detailed)"
|
|
105158
|
+
},
|
|
105159
|
+
engine: {
|
|
105160
|
+
title: "Recording engine",
|
|
105161
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
105162
|
+
anyOf: [
|
|
105163
|
+
{
|
|
105164
|
+
title: "Recording engine (simple)",
|
|
105165
|
+
type: "string",
|
|
105166
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105167
|
+
enum: [
|
|
105168
|
+
"browser",
|
|
105169
|
+
"ffmpeg"
|
|
105170
|
+
]
|
|
105171
|
+
},
|
|
105172
|
+
{
|
|
105173
|
+
title: "Recording engine (detailed)",
|
|
105174
|
+
type: "object",
|
|
105175
|
+
additionalProperties: false,
|
|
105176
|
+
required: [
|
|
105177
|
+
"name"
|
|
105178
|
+
],
|
|
105179
|
+
properties: {
|
|
105180
|
+
name: {
|
|
105181
|
+
type: "string",
|
|
105182
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
105183
|
+
enum: [
|
|
105184
|
+
"browser",
|
|
105185
|
+
"ffmpeg"
|
|
105186
|
+
]
|
|
105187
|
+
},
|
|
105188
|
+
target: {
|
|
105189
|
+
type: "string",
|
|
105190
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
105191
|
+
enum: [
|
|
105192
|
+
"display",
|
|
105193
|
+
"window",
|
|
105194
|
+
"viewport"
|
|
105195
|
+
],
|
|
105196
|
+
default: "display"
|
|
105197
|
+
},
|
|
105198
|
+
fps: {
|
|
105199
|
+
type: "integer",
|
|
105200
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
105201
|
+
default: 30,
|
|
105202
|
+
minimum: 1
|
|
105203
|
+
}
|
|
105204
|
+
}
|
|
105205
|
+
}
|
|
105206
|
+
]
|
|
103311
105207
|
}
|
|
103312
105208
|
}
|
|
103313
105209
|
},
|
|
@@ -103318,6 +105214,18 @@ var schemas_default = {
|
|
|
103318
105214
|
path: "results.mp4",
|
|
103319
105215
|
directory: "static/media",
|
|
103320
105216
|
overwrite: "true"
|
|
105217
|
+
},
|
|
105218
|
+
{
|
|
105219
|
+
path: "results.mp4",
|
|
105220
|
+
engine: "ffmpeg"
|
|
105221
|
+
},
|
|
105222
|
+
{
|
|
105223
|
+
path: "results.mp4",
|
|
105224
|
+
engine: {
|
|
105225
|
+
name: "ffmpeg",
|
|
105226
|
+
target: "window",
|
|
105227
|
+
fps: 60
|
|
105228
|
+
}
|
|
103321
105229
|
}
|
|
103322
105230
|
]
|
|
103323
105231
|
}
|
|
@@ -111895,7 +113803,7 @@ var schemas_default = {
|
|
|
111895
113803
|
record: {
|
|
111896
113804
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
111897
113805
|
title: "record",
|
|
111898
|
-
description: "Start recording
|
|
113806
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
111899
113807
|
anyOf: [
|
|
111900
113808
|
{
|
|
111901
113809
|
title: "Record (simple)",
|
|
@@ -111931,6 +113839,55 @@ var schemas_default = {
|
|
|
111931
113839
|
"true",
|
|
111932
113840
|
"false"
|
|
111933
113841
|
]
|
|
113842
|
+
},
|
|
113843
|
+
engine: {
|
|
113844
|
+
title: "Recording engine",
|
|
113845
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
113846
|
+
anyOf: [
|
|
113847
|
+
{
|
|
113848
|
+
title: "Recording engine (simple)",
|
|
113849
|
+
type: "string",
|
|
113850
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
113851
|
+
enum: [
|
|
113852
|
+
"browser",
|
|
113853
|
+
"ffmpeg"
|
|
113854
|
+
]
|
|
113855
|
+
},
|
|
113856
|
+
{
|
|
113857
|
+
title: "Recording engine (detailed)",
|
|
113858
|
+
type: "object",
|
|
113859
|
+
additionalProperties: false,
|
|
113860
|
+
required: [
|
|
113861
|
+
"name"
|
|
113862
|
+
],
|
|
113863
|
+
properties: {
|
|
113864
|
+
name: {
|
|
113865
|
+
type: "string",
|
|
113866
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
113867
|
+
enum: [
|
|
113868
|
+
"browser",
|
|
113869
|
+
"ffmpeg"
|
|
113870
|
+
]
|
|
113871
|
+
},
|
|
113872
|
+
target: {
|
|
113873
|
+
type: "string",
|
|
113874
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
113875
|
+
enum: [
|
|
113876
|
+
"display",
|
|
113877
|
+
"window",
|
|
113878
|
+
"viewport"
|
|
113879
|
+
],
|
|
113880
|
+
default: "display"
|
|
113881
|
+
},
|
|
113882
|
+
fps: {
|
|
113883
|
+
type: "integer",
|
|
113884
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
113885
|
+
default: 30,
|
|
113886
|
+
minimum: 1
|
|
113887
|
+
}
|
|
113888
|
+
}
|
|
113889
|
+
}
|
|
113890
|
+
]
|
|
111934
113891
|
}
|
|
111935
113892
|
},
|
|
111936
113893
|
title: "Record (detailed)"
|
|
@@ -111938,7 +113895,7 @@ var schemas_default = {
|
|
|
111938
113895
|
{
|
|
111939
113896
|
type: "boolean",
|
|
111940
113897
|
title: "Record (boolean)",
|
|
111941
|
-
description: "If `true`,
|
|
113898
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
111942
113899
|
}
|
|
111943
113900
|
],
|
|
111944
113901
|
components: {
|
|
@@ -111977,9 +113934,107 @@ var schemas_default = {
|
|
|
111977
113934
|
"true",
|
|
111978
113935
|
"false"
|
|
111979
113936
|
]
|
|
113937
|
+
},
|
|
113938
|
+
engine: {
|
|
113939
|
+
title: "Recording engine",
|
|
113940
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
113941
|
+
anyOf: [
|
|
113942
|
+
{
|
|
113943
|
+
title: "Recording engine (simple)",
|
|
113944
|
+
type: "string",
|
|
113945
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
113946
|
+
enum: [
|
|
113947
|
+
"browser",
|
|
113948
|
+
"ffmpeg"
|
|
113949
|
+
]
|
|
113950
|
+
},
|
|
113951
|
+
{
|
|
113952
|
+
title: "Recording engine (detailed)",
|
|
113953
|
+
type: "object",
|
|
113954
|
+
additionalProperties: false,
|
|
113955
|
+
required: [
|
|
113956
|
+
"name"
|
|
113957
|
+
],
|
|
113958
|
+
properties: {
|
|
113959
|
+
name: {
|
|
113960
|
+
type: "string",
|
|
113961
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
113962
|
+
enum: [
|
|
113963
|
+
"browser",
|
|
113964
|
+
"ffmpeg"
|
|
113965
|
+
]
|
|
113966
|
+
},
|
|
113967
|
+
target: {
|
|
113968
|
+
type: "string",
|
|
113969
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
113970
|
+
enum: [
|
|
113971
|
+
"display",
|
|
113972
|
+
"window",
|
|
113973
|
+
"viewport"
|
|
113974
|
+
],
|
|
113975
|
+
default: "display"
|
|
113976
|
+
},
|
|
113977
|
+
fps: {
|
|
113978
|
+
type: "integer",
|
|
113979
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
113980
|
+
default: 30,
|
|
113981
|
+
minimum: 1
|
|
113982
|
+
}
|
|
113983
|
+
}
|
|
113984
|
+
}
|
|
113985
|
+
]
|
|
111980
113986
|
}
|
|
111981
113987
|
},
|
|
111982
113988
|
title: "Record (detailed)"
|
|
113989
|
+
},
|
|
113990
|
+
engine: {
|
|
113991
|
+
title: "Recording engine",
|
|
113992
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
113993
|
+
anyOf: [
|
|
113994
|
+
{
|
|
113995
|
+
title: "Recording engine (simple)",
|
|
113996
|
+
type: "string",
|
|
113997
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
113998
|
+
enum: [
|
|
113999
|
+
"browser",
|
|
114000
|
+
"ffmpeg"
|
|
114001
|
+
]
|
|
114002
|
+
},
|
|
114003
|
+
{
|
|
114004
|
+
title: "Recording engine (detailed)",
|
|
114005
|
+
type: "object",
|
|
114006
|
+
additionalProperties: false,
|
|
114007
|
+
required: [
|
|
114008
|
+
"name"
|
|
114009
|
+
],
|
|
114010
|
+
properties: {
|
|
114011
|
+
name: {
|
|
114012
|
+
type: "string",
|
|
114013
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
114014
|
+
enum: [
|
|
114015
|
+
"browser",
|
|
114016
|
+
"ffmpeg"
|
|
114017
|
+
]
|
|
114018
|
+
},
|
|
114019
|
+
target: {
|
|
114020
|
+
type: "string",
|
|
114021
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
114022
|
+
enum: [
|
|
114023
|
+
"display",
|
|
114024
|
+
"window",
|
|
114025
|
+
"viewport"
|
|
114026
|
+
],
|
|
114027
|
+
default: "display"
|
|
114028
|
+
},
|
|
114029
|
+
fps: {
|
|
114030
|
+
type: "integer",
|
|
114031
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
114032
|
+
default: 30,
|
|
114033
|
+
minimum: 1
|
|
114034
|
+
}
|
|
114035
|
+
}
|
|
114036
|
+
}
|
|
114037
|
+
]
|
|
111983
114038
|
}
|
|
111984
114039
|
}
|
|
111985
114040
|
},
|
|
@@ -111990,6 +114045,18 @@ var schemas_default = {
|
|
|
111990
114045
|
path: "results.mp4",
|
|
111991
114046
|
directory: "static/media",
|
|
111992
114047
|
overwrite: "true"
|
|
114048
|
+
},
|
|
114049
|
+
{
|
|
114050
|
+
path: "results.mp4",
|
|
114051
|
+
engine: "ffmpeg"
|
|
114052
|
+
},
|
|
114053
|
+
{
|
|
114054
|
+
path: "results.mp4",
|
|
114055
|
+
engine: {
|
|
114056
|
+
name: "ffmpeg",
|
|
114057
|
+
target: "window",
|
|
114058
|
+
fps: 60
|
|
114059
|
+
}
|
|
111993
114060
|
}
|
|
111994
114061
|
]
|
|
111995
114062
|
}
|
|
@@ -120210,7 +122277,7 @@ var schemas_default = {
|
|
|
120210
122277
|
record: {
|
|
120211
122278
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
120212
122279
|
title: "record",
|
|
120213
|
-
description: "Start recording
|
|
122280
|
+
description: "Start recording. Must be followed by a `stopRecord` step. The `browser` engine captures the Chrome viewport (works under concurrency); the `ffmpeg` engine captures the screen and supports any application. Supported extensions: [ '.mp4', '.webm', '.gif' ]",
|
|
120214
122281
|
anyOf: [
|
|
120215
122282
|
{
|
|
120216
122283
|
title: "Record (simple)",
|
|
@@ -120246,6 +122313,55 @@ var schemas_default = {
|
|
|
120246
122313
|
"true",
|
|
120247
122314
|
"false"
|
|
120248
122315
|
]
|
|
122316
|
+
},
|
|
122317
|
+
engine: {
|
|
122318
|
+
title: "Recording engine",
|
|
122319
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
122320
|
+
anyOf: [
|
|
122321
|
+
{
|
|
122322
|
+
title: "Recording engine (simple)",
|
|
122323
|
+
type: "string",
|
|
122324
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122325
|
+
enum: [
|
|
122326
|
+
"browser",
|
|
122327
|
+
"ffmpeg"
|
|
122328
|
+
]
|
|
122329
|
+
},
|
|
122330
|
+
{
|
|
122331
|
+
title: "Recording engine (detailed)",
|
|
122332
|
+
type: "object",
|
|
122333
|
+
additionalProperties: false,
|
|
122334
|
+
required: [
|
|
122335
|
+
"name"
|
|
122336
|
+
],
|
|
122337
|
+
properties: {
|
|
122338
|
+
name: {
|
|
122339
|
+
type: "string",
|
|
122340
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122341
|
+
enum: [
|
|
122342
|
+
"browser",
|
|
122343
|
+
"ffmpeg"
|
|
122344
|
+
]
|
|
122345
|
+
},
|
|
122346
|
+
target: {
|
|
122347
|
+
type: "string",
|
|
122348
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
122349
|
+
enum: [
|
|
122350
|
+
"display",
|
|
122351
|
+
"window",
|
|
122352
|
+
"viewport"
|
|
122353
|
+
],
|
|
122354
|
+
default: "display"
|
|
122355
|
+
},
|
|
122356
|
+
fps: {
|
|
122357
|
+
type: "integer",
|
|
122358
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
122359
|
+
default: 30,
|
|
122360
|
+
minimum: 1
|
|
122361
|
+
}
|
|
122362
|
+
}
|
|
122363
|
+
}
|
|
122364
|
+
]
|
|
120249
122365
|
}
|
|
120250
122366
|
},
|
|
120251
122367
|
title: "Record (detailed)"
|
|
@@ -120253,7 +122369,7 @@ var schemas_default = {
|
|
|
120253
122369
|
{
|
|
120254
122370
|
type: "boolean",
|
|
120255
122371
|
title: "Record (boolean)",
|
|
120256
|
-
description: "If `true`,
|
|
122372
|
+
description: "If `true`, starts recording \u2014 auto-selecting the `browser` engine for a visible Chrome context and the `ffmpeg` engine otherwise. If `false`, doesn't record."
|
|
120257
122373
|
}
|
|
120258
122374
|
],
|
|
120259
122375
|
components: {
|
|
@@ -120292,9 +122408,107 @@ var schemas_default = {
|
|
|
120292
122408
|
"true",
|
|
120293
122409
|
"false"
|
|
120294
122410
|
]
|
|
122411
|
+
},
|
|
122412
|
+
engine: {
|
|
122413
|
+
title: "Recording engine",
|
|
122414
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
122415
|
+
anyOf: [
|
|
122416
|
+
{
|
|
122417
|
+
title: "Recording engine (simple)",
|
|
122418
|
+
type: "string",
|
|
122419
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122420
|
+
enum: [
|
|
122421
|
+
"browser",
|
|
122422
|
+
"ffmpeg"
|
|
122423
|
+
]
|
|
122424
|
+
},
|
|
122425
|
+
{
|
|
122426
|
+
title: "Recording engine (detailed)",
|
|
122427
|
+
type: "object",
|
|
122428
|
+
additionalProperties: false,
|
|
122429
|
+
required: [
|
|
122430
|
+
"name"
|
|
122431
|
+
],
|
|
122432
|
+
properties: {
|
|
122433
|
+
name: {
|
|
122434
|
+
type: "string",
|
|
122435
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122436
|
+
enum: [
|
|
122437
|
+
"browser",
|
|
122438
|
+
"ffmpeg"
|
|
122439
|
+
]
|
|
122440
|
+
},
|
|
122441
|
+
target: {
|
|
122442
|
+
type: "string",
|
|
122443
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
122444
|
+
enum: [
|
|
122445
|
+
"display",
|
|
122446
|
+
"window",
|
|
122447
|
+
"viewport"
|
|
122448
|
+
],
|
|
122449
|
+
default: "display"
|
|
122450
|
+
},
|
|
122451
|
+
fps: {
|
|
122452
|
+
type: "integer",
|
|
122453
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
122454
|
+
default: 30,
|
|
122455
|
+
minimum: 1
|
|
122456
|
+
}
|
|
122457
|
+
}
|
|
122458
|
+
}
|
|
122459
|
+
]
|
|
120295
122460
|
}
|
|
120296
122461
|
},
|
|
120297
122462
|
title: "Record (detailed)"
|
|
122463
|
+
},
|
|
122464
|
+
engine: {
|
|
122465
|
+
title: "Recording engine",
|
|
122466
|
+
description: "Recording engine to use. Either a string shorthand selecting the engine with defaults, or an object for full control. If unset, defaults to the `browser` engine when a visible Chrome context is available and to `ffmpeg` otherwise.",
|
|
122467
|
+
anyOf: [
|
|
122468
|
+
{
|
|
122469
|
+
title: "Recording engine (simple)",
|
|
122470
|
+
type: "string",
|
|
122471
|
+
description: "`browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122472
|
+
enum: [
|
|
122473
|
+
"browser",
|
|
122474
|
+
"ffmpeg"
|
|
122475
|
+
]
|
|
122476
|
+
},
|
|
122477
|
+
{
|
|
122478
|
+
title: "Recording engine (detailed)",
|
|
122479
|
+
type: "object",
|
|
122480
|
+
additionalProperties: false,
|
|
122481
|
+
required: [
|
|
122482
|
+
"name"
|
|
122483
|
+
],
|
|
122484
|
+
properties: {
|
|
122485
|
+
name: {
|
|
122486
|
+
type: "string",
|
|
122487
|
+
description: "Recording engine. `browser` records the Chrome viewport (concurrency-safe); `ffmpeg` records the screen and supports any application.",
|
|
122488
|
+
enum: [
|
|
122489
|
+
"browser",
|
|
122490
|
+
"ffmpeg"
|
|
122491
|
+
]
|
|
122492
|
+
},
|
|
122493
|
+
target: {
|
|
122494
|
+
type: "string",
|
|
122495
|
+
description: "What the `ffmpeg` engine captures. `display` records the full screen, `window` the active window, `viewport` the browser content area. Ignored by the `browser` engine, which always captures its tab. `window` and `viewport` are best-effort (captured full-screen, then cropped).",
|
|
122496
|
+
enum: [
|
|
122497
|
+
"display",
|
|
122498
|
+
"window",
|
|
122499
|
+
"viewport"
|
|
122500
|
+
],
|
|
122501
|
+
default: "display"
|
|
122502
|
+
},
|
|
122503
|
+
fps: {
|
|
122504
|
+
type: "integer",
|
|
122505
|
+
description: "Capture frame rate for the `ffmpeg` engine.",
|
|
122506
|
+
default: 30,
|
|
122507
|
+
minimum: 1
|
|
122508
|
+
}
|
|
122509
|
+
}
|
|
122510
|
+
}
|
|
122511
|
+
]
|
|
120298
122512
|
}
|
|
120299
122513
|
}
|
|
120300
122514
|
},
|
|
@@ -120305,6 +122519,18 @@ var schemas_default = {
|
|
|
120305
122519
|
path: "results.mp4",
|
|
120306
122520
|
directory: "static/media",
|
|
120307
122521
|
overwrite: "true"
|
|
122522
|
+
},
|
|
122523
|
+
{
|
|
122524
|
+
path: "results.mp4",
|
|
122525
|
+
engine: "ffmpeg"
|
|
122526
|
+
},
|
|
122527
|
+
{
|
|
122528
|
+
path: "results.mp4",
|
|
122529
|
+
engine: {
|
|
122530
|
+
name: "ffmpeg",
|
|
122531
|
+
target: "window",
|
|
122532
|
+
fps: 60
|
|
122533
|
+
}
|
|
120308
122534
|
}
|
|
120309
122535
|
]
|
|
120310
122536
|
}
|