insync-stage-handler 3.1.2 → 4.0.0-beta.1

package/dist/library.js

@@ -2,14 +2,35 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
 var R = require('ramda');
-var Ajv = _interopDefault(require('ajv'));
+var Ajv = require('ajv');
 var fp = require('date-fns/fp');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespace(R);
+var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
+
 const lookup = R.flip(R.prop);
-const lookupPath = R.flip(R.path);
+R.flip(R.path);
 const lookupAll = R.curry((from, ids) => R.map(lookup(from), ids));
 const lookupPathAll = R.curry((from, p, ids) => R.map(R.compose(R.path(p), lookup(from)), ids));
 const indexById = R.indexBy(R.prop("id"));
@@ -19,16 +40,13 @@ const listEntities = R.curry((entitiesContainerPath, from) => R.pipe(R.converge(
  * Return the version of a stage object.
  * @param {Object} stage The stage for which to return the version.
  */
-
 var detectVersion = R.pipe(R.prop("version"), R.defaultTo(1));
 
 class ValidationError extends Error {
   setErrors(errors) {
     this.errors = errors;
   }
-
 }
-
 const formatErrorMessage = errors => {
   const header = "Validation errors occurred: \n";
   return R.pipe(R.map(({
@@ -36,26 +54,22 @@ const formatErrorMessage = errors => {
     message
   }) => `path: "${dataPath}",  message: ${message}`), R.map(R.of), R.map(R.pipe(R.prepend("  - "), R.append("\n"))), R.flatten, R.prepend(header), R.join(""))(errors);
 };
-
-var createValidationError = (errors => {
+var createValidationError = errors => {
   const err = new ValidationError(formatErrorMessage(errors));
   err.setErrors(errors);
   return err;
-});
+};
 
-const ajv = new Ajv({
+const ajv = new Ajv__default["default"]({
   $data: true,
   allErrors: true,
   logger: false
 });
-
 require("ajv-keywords")(ajv, "formatMinimum");
 /**
  * Creates a JSON schema validator.
  * @param {Object} obj Object containing json schema rules.
  */
-
-
 const createAJVValidator = schema => {
   const validator = ajv.compile(schema);
   return stage => {
@@ -71,11 +85,11 @@ const createAJVValidator = schema => {
   };
 };
 
-var $schema = "http://json-schema.org/draft-07/schema#";
-var id = "stage.1.schema.json";
-var description = "Version 1 of stage file";
-var type = "object";
-var definitions = {
+var $schema$3 = "http://json-schema.org/draft-07/schema#";
+var id$3 = "stage.1.schema.json";
+var description$4 = "Version 1 of stage file";
+var type$3 = "object";
+var definitions$3 = {
 	entitiesContainer: {
 		type: "object",
 		properties: {
@@ -623,7 +637,7 @@ var definitions = {
 		]
 	}
 };
-var properties = {
+var properties$3 = {
 	menu: {
 		type: "object",
 		properties: {
@@ -765,25 +779,25 @@ var properties = {
 		}
 	}
 };
-var schema = {
-	$schema: $schema,
-	id: id,
-	description: description,
-	type: type,
-	definitions: definitions,
-	properties: properties
+var schema$3 = {
+	$schema: $schema$3,
+	id: id$3,
+	description: description$4,
+	type: type$3,
+	definitions: definitions$3,
+	properties: properties$3
 };
 
-const jsonSchemaValidator = createAJVValidator(schema);
-var v1 = (stage => {
-  return jsonSchemaValidator(stage);
-});
+const jsonSchemaValidator$3 = createAJVValidator(schema$3);
+var v1 = stage => {
+  return jsonSchemaValidator$3(stage);
+};
 
-var $schema$1 = "http://json-schema.org/draft-07/schema#";
-var id$1 = "stage.2.schema.json";
-var description$1 = "Version 2 of stage file";
-var type$1 = "object";
-var definitions$1 = {
+var $schema$2 = "http://json-schema.org/draft-07/schema#";
+var id$2 = "stage.2.schema.json";
+var description$3 = "Version 2 of stage file";
+var type$2 = "object";
+var definitions$2 = {
 	entitiesContainer: {
 		type: "object",
 		properties: {
@@ -1344,7 +1358,7 @@ var definitions$1 = {
 		]
 	}
 };
-var properties$1 = {
+var properties$2 = {
 	menu: {
 		type: "object",
 		properties: {
@@ -1486,25 +1500,25 @@ var properties$1 = {
 		}
 	}
 };
-var schema$1 = {
-	$schema: $schema$1,
-	id: id$1,
-	description: description$1,
-	type: type$1,
-	definitions: definitions$1,
-	properties: properties$1
+var schema$2 = {
+	$schema: $schema$2,
+	id: id$2,
+	description: description$3,
+	type: type$2,
+	definitions: definitions$2,
+	properties: properties$2
 };
 
-const jsonSchemaValidator$1 = createAJVValidator(schema$1);
-var v2 = (stage => {
-  return jsonSchemaValidator$1(stage);
-});
+const jsonSchemaValidator$2 = createAJVValidator(schema$2);
+var v2 = stage => {
+  return jsonSchemaValidator$2(stage);
+};
 
-var $schema$2 = "http://json-schema.org/draft-07/schema#";
-var id$2 = "stage.3.schema.json";
+var $schema$1 = "http://json-schema.org/draft-07/schema#";
+var id$1 = "stage.3.schema.json";
 var description$2 = "Version 3 of stage file";
-var type$2 = "object";
-var definitions$2 = {
+var type$1 = "object";
+var definitions$1 = {
 	entitiesContainer: {
 		type: "object",
 		properties: {
@@ -2061,7 +2075,7 @@ var definitions$2 = {
 		]
 	}
 };
-var properties$2 = {
+var properties$1 = {
 	menu: {
 		type: "object",
 		properties: {
@@ -2200,299 +2214,1096 @@ var properties$2 = {
 		}
 	}
 };
-var schema$2 = {
-	$schema: $schema$2,
-	id: id$2,
+var schema$1 = {
+	$schema: $schema$1,
+	id: id$1,
 	description: description$2,
-	type: type$2,
-	definitions: definitions$2,
-	properties: properties$2
-};
-
-const jsonSchemaValidator$2 = createAJVValidator(schema$2);
-var v3 = (stage => {
-  return jsonSchemaValidator$2(stage);
-});
-
-const map = Object.freeze({
-  "1": v1,
-  "2": v2,
-  "3": v3
-});
-
-/**
- * Parses validation specific options from global options.
- * @param {obj} options
- */
-
-const optionsParser = ({
-  validationVersion = undefined
-}) => ({
-  version: validationVersion
-});
-/**
- * Validates a stage
- * @param {Object} stage
- * @param {number} version
- */
-
-var validate = ((stage, options = {}) => {
-  const {
-    version = undefined
-  } = options;
-  return R.pipe(R.defaultTo(detectVersion(stage)), lookup(map), R.applyTo(stage))(version);
-});
-
-var versions = Object.freeze([1, 2, 3]);
-
-/**
- * v1-to-v2.js
- * Upgrader for version 1 stage files to version 2.
- * Removes timelines axes with resources. And adds the zoomSteps for the dataviewer.
- */
-const outletsView = listEntities(["data", "entities", "outlets"]); // This adds the zoomsteps on dataviwer based on "visible" prop on the associated outlet.
-
-const addDataViewerZoomSteps = stage => R.pipe(outletsView, // The association to a dataviewer is defined in the outlet id (dataviewer/<DATAVIEWER ID>),
-// This only takes outlets associated with a dataviewer.
-R.filter(R.propSatisfies(R.startsWith("dataviewer/"), "id")), R.map( // This pairs the path to the associated dataviewer to its required zoomSteps.
-R.converge(R.pair, [R.pipe(R.prop("id"), R.replace("dataviewer/", ""), id => ["data", "entities", "dataViewers", "byId", id, "zoomSteps"]), R.pipe(R.prop("visible"), visible => [visible])])), // Set the "zoomSteps" prop of the dataviewer to the visibility of the outlet.
-R.reduce((acc, [path, zoomSteps]) => R.assocPath(path, zoomSteps, acc), stage))(stage);
-
-var v1ToV2 = R.pipe( // Sets the version prop to "2"
-R.assoc("version", 2), // Remove the association to resources from the timline axes.
-// In version 2 the tracks for files on the timeline are handled by the v2 consolidation strategy.
-R.dissocPath(["timeline", "entities", "axes", "byId", "video", "resources"]), R.dissocPath(["timeline", "entities", "axes", "byId", "high-speed", "resources"]), // Adds the zoomsteps to the dataviewers.
-addDataViewerZoomSteps);
-
-const NEW_TEST_REGEX = /^([0-9]{5})_(.+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)$/;
-
-const fsPath = require("path");
-
-const match = R.curry((regex, st) => st.match(regex));
-const mapWithIndex = R.addIndex(R.map);
-const axesSettings = [{
-  id: "video",
-  color: "#41b51b"
-}, {
-  id: "high-speed",
-  color: "#3318cc"
-}, {
-  id: "comment",
-  color: "red"
-}];
-const tracksIdsPath = ["timeline", "entities", "tracks", "ids"];
-const tracksByIdPath = ["timeline", "entities", "tracks", "byId"];
-const axesIdsPath = ["timeline", "entities", "axes", "ids"];
-const axesByIdPath = ["timeline", "entities", "axes", "byId"];
-const resourcesIdsView = R.path(["resources", "entities", "resources", "ids"]);
-const resourcesByIdView = R.path(["resources", "entities", "resources", "byId"]);
-const filesIdsView = R.path(["files", "entities", "files", "ids"]);
-const filesByIdView = R.path(["files", "entities", "files", "byId"]);
-const commentsByIdView = R.path(["timeline", "entities", "comments", "byId"]);
-const tracksIdsLens = R.lensPath(tracksIdsPath);
-const tracksByIdLens = R.lensPath(tracksByIdPath);
-const axesIdsLens = R.lensPath(axesIdsPath);
-const axesByIdLens = R.lensPath(axesByIdPath);
-const filesView = R.pipe(filesByIdView, R.values);
-const commentsView = R.pipe(commentsByIdView, R.values);
-
-const highSpeedsFilesView = stage => {
-  const filesById = filesByIdView(stage);
-  const resourcesById = resourcesByIdView(stage);
-  return R.pipe( // Iterate R.over the resource ids
-  resourcesIdsView, // Filter out all the ids that don't start with high-speed.
-  R.filter(R.startsWith("high-speed:")), // Map the remaining resource ids to the files ids in the respective resource object.
-  lookupPathAll(resourcesById, ["files"]), // Flatten the ids so we get a single array containing all the files ids referred
-  // to across all high-speed resources.
-  R.flatten, // Map the file ids to file objects.
-  lookupAll(filesById))(stage);
-};
-
-const videosFilesView = stage => {
-  const filesIds = filesIdsView(stage);
-  const filesById = filesByIdView(stage);
-  const highSpeedFiles = highSpeedsFilesView(stage);
-  return R.pipe(R.without(R.pluck("id", highSpeedFiles)), lookupAll(filesById), R.filter(R.propEq("type", "video")))(filesIds);
-};
-
-const upsertAxes = axes => R.curry(R.pipe(R.unless(R.path(axesIdsPath), R.assocPath(axesIdsPath, [])), R.unless(R.path(axesByIdPath), R.assocPath(axesIdsPath, {})), R.over(axesIdsLens, R.union(R.pluck("id", axes))), R.over(axesByIdLens, R.merge(indexById(axes)))));
-const createTrackFromEntity = R.curry((axis, entity) => {
-  const {
-    start,
-    end,
-    type,
-    id
-  } = entity;
-  return {
-    id: `track:${id}`,
-    start,
-    end,
-    type,
-    axisRef: axis,
-    ref: id
-  };
-});
-const mapEntitiesToTracks = R.curry((entitiesSelector, axis, stage) => R.map(createTrackFromEntity(axis), entitiesSelector(stage)));
-const mapCommentsToTracks = R.pipe(mapEntitiesToTracks(commentsView, "comment"), R.map(R.mergeLeft({
-  type: "comment",
-  label: "comment"
-})));
-
-const formatTestNo = input => {
-  const [// eslint-disable-next-line no-unused-vars
-  m, project, facility, program, category, test, experiment, measurement] = input.match(NEW_TEST_REGEX);
-  return `${project}_${program.padStart(2, "0")}${facility}_${category.padStart(2, "0")}_${test.padStart(3, "0")}_${experiment.padStart(3, "0")}_${measurement.padStart(2, "0")}`;
-};
-
-const extractTestNumberFromMetadata = R.pipe(R.path(["metadata", "location", "$id"]), R.when(R.test(NEW_TEST_REGEX), formatTestNo));
-const extractTestNumberFromFileName = R.compose(R.head, R.defaultTo([undefined]), R.either(match(/[0-9]{5}_[0-9]{2}[a-zA-Z]+_[0-9]{2}_[0-9]{3}_[0-9]{3}_[0-9]{2}/), match(/[A-Za-z]+[0-9]{5}_[0-9]+_[0-9]+_[0-9]+/)), R.prop("path"));
-
-const extractTestNumber = (stage, track) => R.pipe(filesByIdView, R.prop(track.ref), R.either(extractTestNumberFromMetadata, extractTestNumberFromFileName))(stage);
-
-const formatter = fp.formatWithOptions({
-  awareOfUnicodeTokens: true
-});
-
-const extractRecordingChannel = (stage, track) => R.pipe(filesByIdView, R.path([track.ref, "metadata", "recChannel"]))(stage);
-
-const createHighSpeedTracksLabels = stage => tracks => mapWithIndex((hs, index) => {
-  const recordingChannel = extractRecordingChannel(stage, hs);
-  const no = recordingChannel || index + 1;
-  return R.assoc("label", `HS ${no}`, hs);
-}, tracks);
-
-const createVideoTracksLabels = stage => tracks => mapWithIndex((vid, index) => {
-  const recordingChannel = extractRecordingChannel(stage, vid);
-  const no = recordingChannel || index + 1;
-  return R.assoc("label", `VID ${no}`, vid);
-}, tracks);
-
-const extractFormat = (stage, track) => R.pipe(filesByIdView, R.path([track.ref, "path"]), p => fsPath.extname(p))(stage);
-
-const extractSecondFractions = isoStr => R.pipe(match(/[0-9]{2}:[0-9]{2}:[0-9]{2}.([0-9]+)/), R.ifElse(R.isNil, R.always("000"), R.nth(1)))(isoStr);
-
-const extractDate = (stage, track) => {
-  return R.pipe(filesByIdView, R.path([track.ref, "start"]), fp.parseISO, formatter("dd-MM-yyyy"))(stage);
-};
-
-const createTime = R.converge(R.pipe(R.pair, R.join(".")), [R.pipe(fp.parseISO, formatter("HH:mm:ss")), extractSecondFractions]);
-
-const extractStart = (stage, track) => R.pipe(filesByIdView, R.path([track.ref, "start"]), createTime)(stage);
-
-const extractEnd = (stage, track) => R.pipe(filesByIdView, R.path([track.ref, "end"]), createTime)(stage);
-
-const createVideoMetadata = R.curry((type, stage, track) => ({ ...track,
-  metadata: track.metadata || [[{
-    label: "Test",
-    value: extractTestNumber(stage, track)
-  }], [{
-    label: "Type",
-    value: type
-  }, {
-    label: "Recording channel",
-    value: extractRecordingChannel(stage, track)
-  }, {
-    label: "Format",
-    value: extractFormat(stage, track)
-  }], [{
-    label: "Date",
-    value: extractDate(stage, track)
-  }, {
-    label: "Start",
-    value: extractStart(stage, track)
-  }, {
-    label: "End",
-    value: extractEnd(stage, track)
-  }]]
-}));
-const createHighSpeedsMetadata = R.curry((stage, tracks) => R.map(createVideoMetadata("high-speed", stage), tracks));
-const createVideosMetadata = R.curry((stage, tracks) => R.map(createVideoMetadata("video", stage), tracks));
-
-const createTracks = stage => R.converge((...args) => R.flatten(args), [R.pipe(mapEntitiesToTracks(highSpeedsFilesView, "high-speed"), createHighSpeedTracksLabels(stage), createHighSpeedsMetadata(stage)), R.pipe(mapEntitiesToTracks(videosFilesView, "video"), createVideoTracksLabels(stage), createVideosMetadata(stage)), mapCommentsToTracks])(stage);
-
-const upsertTracks = tracks => R.curry(R.pipe(R.unless(R.path(tracksIdsPath), R.assocPath(tracksIdsPath, [])), R.unless(R.path(tracksByIdPath), R.assocPath(tracksByIdPath, {})), R.over(tracksIdsLens, R.union(R.pluck("id", tracks))), R.over(tracksByIdLens, R.merge(indexById(tracks)))));
-
-const earliestTime = stage => R.pipe(filesView, R.map(R.prop("start")), R.map(Date.parse), R.apply(Math.min), t => new Date(t), d => d.toISOString())(stage);
-
-const latestTime = stage => R.pipe(filesView, R.map(R.prop("end")), R.map(Date.parse), R.apply(Math.max), t => new Date(t), d => d.toISOString())(stage);
-
-const setTimeLineStartEnd = stage => R.pipe(R.assocPath(["timeline", "start"], earliestTime(stage)), R.assocPath(["timeline", "end"], latestTime(stage)))(stage);
-
-const setCommentAxis = R.assocPath(["timeline", "commentAxis"], "comment");
-
-const consolidateTimeline = stage => {
-  return R.pipe(upsertAxes(axesSettings), upsertTracks(createTracks(stage)), setTimeLineStartEnd, setCommentAxis)(stage);
+	type: type$1,
+	definitions: definitions$1,
+	properties: properties$1
 };
 
-const consolidate = stage => {
-  return consolidateTimeline(stage);
+const jsonSchemaValidator$1 = createAJVValidator(schema$1);
+var v3$1 = stage => {
+  return jsonSchemaValidator$1(stage);
 };
 
-const NEW_TEST_REGEX$1 = /^([0-9]{5})_(.+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)$/;
-
-const fsPath$1 = require("path");
-
-const match$1 = R.curry((regex, st) => st.match(regex));
-const mapWithIndex$1 = R.addIndex(R.map);
-const axesSettings$1 = [{
-  id: "video",
-  color: "#41b51b"
-}, {
-  id: "high-speed",
-  color: "#3318cc"
-}, {
-  id: "comment",
-  color: "red"
-}];
-const tracksIdsPath$1 = ["timeline", "entities", "tracks", "ids"];
-const tracksByIdPath$1 = ["timeline", "entities", "tracks", "byId"];
-const axesIdsPath$1 = ["timeline", "entities", "axes", "ids"];
-const axesByIdPath$1 = ["timeline", "entities", "axes", "byId"];
-const resourcesIdsView$1 = R.path(["resources", "entities", "resources", "ids"]);
-const resourcesByIdView$1 = R.path(["resources", "entities", "resources", "byId"]);
-const filesIdsView$1 = R.path(["files", "entities", "files", "ids"]);
-const filesByIdView$1 = R.path(["files", "entities", "files", "byId"]);
-const timingByIdView = R.path(["timing", "entities", "timing", "byId"]);
-const commentsByIdView$1 = R.path(["timeline", "entities", "comments", "byId"]);
-const tracksIdsLens$1 = R.lensPath(tracksIdsPath$1);
-const tracksByIdLens$1 = R.lensPath(tracksByIdPath$1);
-const axesIdsLens$1 = R.lensPath(axesIdsPath$1);
-const axesByIdLens$1 = R.lensPath(axesByIdPath$1);
-const timingsView = R.pipe(timingByIdView, R.values);
-const commentsView$1 = R.pipe(commentsByIdView$1, R.values);
-
-const highSpeedsFilesView$1 = stage => {
-  const filesById = filesByIdView$1(stage);
+var $schema = "http://json-schema.org/draft-07/schema#";
+var id = "stage.4.schema.json";
+var description$1 = "Version 4 of stage file - DockView layout format";
+var type = "object";
+var definitions = {
+	entitiesContainer: {
+		type: "object",
+		properties: {
+			ids: {
+				type: "array",
+				items: {
+					type: "string"
+				}
+			},
+			byId: {
+				type: "object",
+				additionalProperties: {
+					type: "object"
+				}
+			}
+		}
+	},
+	entity: {
+		type: "object",
+		properties: {
+			id: {
+				type: "string"
+			}
+		},
+		required: [
+			"id"
+		]
+	},
+	ref: {
+		type: "object",
+		properties: {
+			type: {
+				type: "string"
+			},
+			id: {
+				type: "string"
+			}
+		}
+	},
+	asset: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					resource: {
+						type: "string"
+					},
+					annotationsViewerId: {
+						type: "string"
+					}
+				}
+			}
+		]
+	},
+	timing: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					start: {
+						format: "date-time",
+						message: "Is not a valid date time"
+					},
+					end: {
+						format: "date-time",
+						message: "Is not a valid date time",
+						formatMinimum: {
+							$data: "1/start"
+						}
+					},
+					ref: {
+						$ref: "#definitions/ref"
+					}
+				},
+				required: [
+					"start",
+					"end",
+					"ref"
+				]
+			}
+		]
+	},
+	file: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					type: {
+						type: "string"
+					},
+					path: {
+						type: "string"
+					},
+					fps: {
+						type: "number"
+					},
+					originalFps: {
+						type: "number"
+					}
+				},
+				required: [
+					"type",
+					"path"
+				],
+				"if": {
+					properties: {
+						type: {
+							"const": "video"
+						}
+					}
+				},
+				then: {
+					required: [
+						"fps"
+					]
+				}
+			}
+		]
+	},
+	resource: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					type: {
+						type: "string"
+					},
+					files: {
+						type: "array",
+						items: {
+							type: "string"
+						}
+					}
+				}
+			}
+		]
+	},
+	dataViewer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					id: {
+						type: "string"
+					},
+					configVisible: {
+						type: "boolean"
+					},
+					configAvailable: {
+						type: "boolean"
+					},
+					measurements: {
+						type: "array",
+						items: {
+							time: "string"
+						}
+					},
+					zoomSteps: {
+						type: "array",
+						items: {
+							type: "number"
+						}
+					},
+					activeZoomStep: {
+						type: "number"
+					}
+				}
+			}
+		]
+	},
+	measurement: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					color: {
+						type: "string"
+					}
+				},
+				required: [
+					"color"
+				]
+			}
+		]
+	},
+	annotation: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					type: {
+						type: "string"
+					},
+					content: {
+						type: "string"
+					},
+					contentRevision: {
+						type: "number"
+					},
+					streamPoints: {
+						type: "array",
+						items: {
+							type: "string"
+						}
+					},
+					textEditable: {
+						type: "boolean"
+					},
+					style: {
+						type: "object"
+					}
+				}
+			}
+		]
+	},
+	streamPoint: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					frequency: {
+						type: "number"
+					},
+					x: {
+						type: "object",
+						properties: {
+							active: {
+								type: "boolean"
+							},
+							scaled: {
+								type: "boolean"
+							},
+							format: {
+								type: "string"
+							}
+						}
+					},
+					y: {
+						type: "object",
+						properties: {
+							active: {
+								type: "boolean"
+							},
+							format: {
+								type: "string"
+							}
+						}
+					},
+					measurement: {
+						type: "string"
+					}
+				}
+			}
+		]
+	},
+	annotationViewer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					id: {
+						type: "string"
+					},
+					active: {
+						type: "boolean"
+					},
+					editable: {
+						type: "boolean"
+					},
+					annotations: {
+						type: "array",
+						items: {
+							type: "string"
+						}
+					},
+					inTextEditMode: {
+						type: "boolean"
+					}
+				}
+			}
+		]
+	},
+	dockviewLeafData: {
+		type: "object",
+		properties: {
+			id: {
+				type: "string"
+			},
+			views: {
+				type: "array",
+				items: {
+					type: "string"
+				}
+			},
+			activeView: {
+				type: "string"
+			}
+		},
+		required: [
+			"id",
+			"views"
+		]
+	},
+	dockviewNode: {
+		oneOf: [
+			{
+				type: "object",
+				properties: {
+					type: {
+						"const": "leaf"
+					},
+					size: {
+						type: "number"
+					},
+					data: {
+						$ref: "#/definitions/dockviewLeafData"
+					}
+				},
+				required: [
+					"type",
+					"data"
+				]
+			},
+			{
+				type: "object",
+				properties: {
+					type: {
+						"const": "branch"
+					},
+					size: {
+						type: "number"
+					},
+					data: {
+						type: "array",
+						items: {
+							$ref: "#/definitions/dockviewNode"
+						}
+					}
+				},
+				required: [
+					"type",
+					"data"
+				]
+			}
+		]
+	},
+	dockviewPanel: {
+		type: "object",
+		properties: {
+			id: {
+				type: "string"
+			},
+			contentComponent: {
+				type: "string"
+			},
+			title: {
+				type: "string"
+			},
+			params: {
+				type: "object"
+			}
+		},
+		required: [
+			"id",
+			"contentComponent",
+			"title",
+			"params"
+		]
+	},
+	dockviewLayout: {
+		type: "object",
+		properties: {
+			grid: {
+				type: "object",
+				properties: {
+					root: {
+						$ref: "#/definitions/dockviewNode"
+					},
+					orientation: {
+						type: "string",
+						"enum": [
+							"HORIZONTAL",
+							"VERTICAL"
+						]
+					},
+					width: {
+						type: "number"
+					},
+					height: {
+						type: "number"
+					}
+				},
+				required: [
+					"root",
+					"orientation",
+					"width",
+					"height"
+				]
+			},
+			panels: {
+				type: "object",
+				additionalProperties: {
+					$ref: "#/definitions/dockviewPanel"
+				}
+			},
+			activeGroup: {
+				type: "string"
+			}
+		},
+		required: [
+			"grid",
+			"panels"
+		]
+	},
+	axis: {
+		allOf: [
+			{
+				$ref: "#/definitions/entity"
+			},
+			{
+				type: "object",
+				properties: {
+					color: {
+						type: "string"
+					},
+					resources: {
+						type: "array",
+						items: {
+							type: "string"
+						}
+					}
+				}
+			}
+		]
+	},
+	assetsContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/asset"
+						}
+					}
+				}
+			}
+		]
+	},
+	annotationsContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/annotation"
+						}
+					}
+				}
+			}
+		]
+	},
+	streamPointsContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/streamPoint"
+						}
+					}
+				}
+			}
+		]
+	},
+	annotationsViewersContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/annotationViewer"
+						}
+					}
+				}
+			}
+		]
+	},
+	dataViewersContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/dataViewer"
+						}
+					}
+				}
+			}
+		]
+	},
+	measurementsContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/measurement"
+						}
+					}
+				}
+			}
+		]
+	},
+	filesContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/file"
+						}
+					}
+				}
+			}
+		]
+	},
+	resourcesContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/resource"
+						}
+					}
+				}
+			}
+		]
+	},
+	axesContainer: {
+		allOf: [
+			{
+				$ref: "#/definitions/entitiesContainer"
+			},
+			{
+				type: "object",
+				properties: {
+					byId: {
+						type: "object",
+						additionalProperties: {
+							$ref: "#/definitions/axis"
+						}
+					}
+				}
+			}
+		]
+	}
+};
+var properties = {
+	version: {
+		type: "number",
+		"const": 4
+	},
+	menu: {
+		type: "object",
+		properties: {
+			visible: {
+				type: "boolean"
+			}
+		}
+	},
+	files: {
+		type: "object",
+		properties: {
+			entities: {
+				type: "object",
+				properties: {
+					files: {
+						$ref: "#/definitions/filesContainer"
+					}
+				}
+			}
+		}
+	},
+	resources: {
+		type: "object",
+		properties: {
+			entities: {
+				type: "object",
+				properties: {
+					resources: {
+						$ref: "#/definitions/resourcesContainer"
+					}
+				}
+			}
+		}
+	},
+	assets: {
+		type: "object",
+		properties: {
+			entities: {
+				type: "object",
+				properties: {
+					assets: {
+						$ref: "#/definitions/assetsContainer"
+					}
+				}
+			}
+		}
+	},
+	layout: {
+		type: "object",
+		properties: {
+			dockviewLayout: {
+				oneOf: [
+					{
+						$ref: "#/definitions/dockviewLayout"
+					},
+					{
+						type: "null"
+					}
+				]
+			},
+			focus: {
+				type: "string"
+			},
+			dragging: {
+				type: "boolean"
+			},
+			resizingPanels: {
+				type: "boolean"
+			}
+		}
+	},
+	data: {
+		type: "object",
+		properties: {
+			measurementScale: {
+				type: "number"
+			},
+			entities: {
+				type: "object",
+				properties: {
+					dataViewers: {
+						$ref: "#/definitions/dataViewersContainer"
+					},
+					measurements: {
+						$ref: "#/definitions/measurementsContainer"
+					}
+				}
+			}
+		}
+	},
+	annotations: {
+		type: "object",
+		properties: {
+			allowed: {
+				type: "boolean"
+			},
+			editorOpen: {
+				type: "boolean"
+			},
+			streamPointSelectorOpen: {
+				type: "boolean"
+			},
+			entities: {
+				type: "object",
+				properties: {
+					annotations: {
+						$ref: "#/definitions/entitiesContainer"
+					},
+					streamPoints: {
+						$ref: "#/definitions/streamPointsContainer"
+					},
+					annotationsViewers: {
+						$ref: "#/definitions/annotationsViewersContainer"
+					}
+				}
+			}
+		}
+	},
+	timeline: {
+		type: "object",
+		properties: {
+			entities: {
+				type: "object",
+				properties: {
+					axes: {
+						$ref: "#/definitions/axesContainer"
+					}
+				}
+			}
+		}
+	},
+	timer: {
+		type: "object",
+		properties: {
+			running: {
+				type: "boolean"
+			},
+			startTime: {
+				oneOf: [
+					{
+						type: "number"
+					},
+					{
+						type: "null"
+					}
+				]
+			},
+			waiting: {
+				type: "boolean"
+			},
+			waitingReasons: {
+				type: "array"
+			},
+			range: {
+				type: "array"
+			},
+			rate: {
+				type: "number"
+			}
+		}
+	}
+};
+var schema = {
+	$schema: $schema,
+	id: id,
+	description: description$1,
+	type: type,
+	definitions: definitions,
+	properties: properties
+};
+
+const jsonSchemaValidator = createAJVValidator(schema);
+var v4 = stage => {
+  return jsonSchemaValidator(stage);
+};
+
+const map = Object.freeze({
+  1: v1,
+  2: v2,
+  3: v3$1,
+  4: v4
+});
+
+/**
+ * Parses validation specific options from global options.
+ * @param {obj} options
+ */
+const optionsParser$1 = ({
+  validationVersion = undefined
+}) => ({
+  version: validationVersion
+});
+
+/**
+ * Validates a stage
+ * @param {Object} stage
+ * @param {number} version
+ */
+
+var validate = (stage, options = {}) => {
+  const {
+    version = undefined
+  } = options;
+  return R.pipe(R.defaultTo(detectVersion(stage)), lookup(map), R.applyTo(stage))(version);
+};
+
+var versions = Object.freeze([1, 2, 3, 4]);
+
+/**
+ * v1-to-v2.js
+ * Upgrader for version 1 stage files to version 2.
+ * Removes timelines axes with resources. And adds the zoomSteps for the dataviewer.
+ */
+const outletsView = listEntities(["data", "entities", "outlets"]);
+
+// This adds the zoomsteps on dataviwer based on "visible" prop on the associated outlet.
+const addDataViewerZoomSteps = stage => R.pipe(outletsView,
+// The association to a dataviewer is defined in the outlet id (dataviewer/<DATAVIEWER ID>),
+// This only takes outlets associated with a dataviewer.
+R.filter(R.propSatisfies(R.startsWith("dataviewer/"), "id")), R.map(
+// This pairs the path to the associated dataviewer to its required zoomSteps.
+R.converge(R.pair, [R.pipe(R.prop("id"), R.replace("dataviewer/", ""), id => ["data", "entities", "dataViewers", "byId", id, "zoomSteps"]), R.pipe(R.prop("visible"), visible => [visible])])),
+// Set the "zoomSteps" prop of the dataviewer to the visibility of the outlet.
+R.reduce((acc, [path, zoomSteps]) => R.assocPath(path, zoomSteps, acc), stage))(stage);
+var v1ToV2 = R.pipe(
+// Sets the version prop to "2"
+R.assoc("version", 2),
+// Remove the association to resources from the timline axes.
+// In version 2 the tracks for files on the timeline are handled by the v2 consolidation strategy.
+R.dissocPath(["timeline", "entities", "axes", "byId", "video", "resources"]), R.dissocPath(["timeline", "entities", "axes", "byId", "high-speed", "resources"]),
+// Adds the zoomsteps to the dataviewers.
+addDataViewerZoomSteps);
+
+const NEW_TEST_REGEX$1 = /^([0-9]{5})_(.+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)$/;
+const fsPath$1 = require("path");
+const match$1 = R__namespace.curry((regex, st) => st.match(regex));
+const mapWithIndex$1 = R__namespace.addIndex(R__namespace.map);
+const axesSettings$1 = [{
+  id: "video",
+  color: "#41b51b"
+}, {
+  id: "high-speed",
+  color: "#3318cc"
+}, {
+  id: "comment",
+  color: "red"
+}];
+const tracksIdsPath$1 = ["timeline", "entities", "tracks", "ids"];
+const tracksByIdPath$1 = ["timeline", "entities", "tracks", "byId"];
+const axesIdsPath$1 = ["timeline", "entities", "axes", "ids"];
+const axesByIdPath$1 = ["timeline", "entities", "axes", "byId"];
+const resourcesIdsView$1 = R__namespace.pathOr([], ["resources", "entities", "resources", "ids"]);
+const resourcesByIdView$1 = R__namespace.pathOr({}, ["resources", "entities", "resources", "byId"]);
+const filesIdsView$1 = R__namespace.pathOr([], ["files", "entities", "files", "ids"]);
+const filesByIdView$1 = R__namespace.pathOr({}, ["files", "entities", "files", "byId"]);
+const commentsByIdView$1 = R__namespace.pathOr({}, ["timeline", "entities", "comments", "byId"]);
+const tracksIdsLens$1 = R__namespace.lensPath(tracksIdsPath$1);
+const tracksByIdLens$1 = R__namespace.lensPath(tracksByIdPath$1);
+const axesIdsLens$1 = R__namespace.lensPath(axesIdsPath$1);
+const axesByIdLens$1 = R__namespace.lensPath(axesByIdPath$1);
+const filesView = R__namespace.pipe(filesByIdView$1, R__namespace.values);
+const commentsView$1 = R__namespace.pipe(commentsByIdView$1, R__namespace.values);
+const highSpeedsFilesView$1 = stage => {
+  const filesById = filesByIdView$1(stage);
   const resourcesById = resourcesByIdView$1(stage);
-  return R.pipe( // Iterate R.over the resource ids
-  resourcesIdsView$1, // Filter out all the ids that don't start with high-speed.
-  R.filter(R.startsWith("high-speed:")), // Map the remaining resource ids to the files ids in the respective resource object.
-  lookupPathAll(resourcesById, ["props", "files"]), // Flatten the ids so we get a single array containing all the files ids referred
+  return R__namespace.pipe(
+  // Iterate R.over the resource ids
+  resourcesIdsView$1,
+  // Filter out all the ids that don't start with high-speed.
+  R__namespace.filter(R__namespace.startsWith("high-speed:")),
+  // Map the remaining resource ids to the files ids in the respective resource object.
+  lookupPathAll(resourcesById, ["files"]),
+  // Flatten the ids so we get a single array containing all the files ids referred
+  // to across all high-speed resources.
+  R__namespace.flatten,
+  // Map the file ids to file objects.
+  lookupAll(filesById))(stage);
+};
+const videosFilesView$1 = stage => {
+  const filesIds = filesIdsView$1(stage);
+  const filesById = filesByIdView$1(stage);
+  const highSpeedFiles = highSpeedsFilesView$1(stage);
+  return R__namespace.pipe(R__namespace.without(R__namespace.pluck("id", highSpeedFiles)), lookupAll(filesById), R__namespace.filter(R__namespace.propEq("video", "type")))(filesIds);
+};
+const upsertAxes$1 = axes => R__namespace.curry(R__namespace.pipe(R__namespace.unless(R__namespace.path(axesIdsPath$1), R__namespace.assocPath(axesIdsPath$1, [])), R__namespace.unless(R__namespace.path(axesByIdPath$1), R__namespace.assocPath(axesIdsPath$1, {})), R__namespace.over(axesIdsLens$1, R__namespace.union(R__namespace.pluck("id", axes))), R__namespace.over(axesByIdLens$1, R__namespace.mergeRight(indexById(axes)))));
+const createTrackFromEntity$1 = R__namespace.curry((axis, entity) => {
+  const {
+    start,
+    end,
+    type,
+    id
+  } = entity;
+  return {
+    id: `track:${id}`,
+    start,
+    end,
+    type,
+    axisRef: axis,
+    ref: id
+  };
+});
+const mapEntitiesToTracks$1 = R__namespace.curry((entitiesSelector, axis, stage) => R__namespace.map(createTrackFromEntity$1(axis), entitiesSelector(stage)));
+const mapCommentsToTracks$1 = R__namespace.pipe(mapEntitiesToTracks$1(commentsView$1, "comment"), R__namespace.map(R__namespace.mergeLeft({
+  type: "comment",
+  label: "comment"
+})));
+const formatTestNo$1 = input => {
+  const [
+  // eslint-disable-next-line no-unused-vars
+  m, project, facility, program, category, test, experiment, measurement] = input.match(NEW_TEST_REGEX$1);
+  return `${project}_${program.padStart(2, "0")}${facility}_${category.padStart(2, "0")}_${test.padStart(3, "0")}_${experiment.padStart(3, "0")}_${measurement.padStart(2, "0")}`;
+};
+const extractTestNumberFromMetadata$1 = R__namespace.pipe(R__namespace.path(["metadata", "location", "$id"]), R__namespace.when(R__namespace.test(NEW_TEST_REGEX$1), formatTestNo$1));
+const extractTestNumberFromFileName$1 = R__namespace.compose(R__namespace.head, R__namespace.defaultTo([undefined]), R__namespace.either(match$1(/[0-9]{5}_[0-9]{2}[a-zA-Z]+_[0-9]{2}_[0-9]{3}_[0-9]{3}_[0-9]{2}/), match$1(/[A-Za-z]+[0-9]{5}_[0-9]+_[0-9]+_[0-9]+/)), R__namespace.prop("path"));
+const extractTestNumber$1 = (stage, track) => R__namespace.pipe(filesByIdView$1, R__namespace.prop(track.ref), R__namespace.either(extractTestNumberFromMetadata$1, extractTestNumberFromFileName$1))(stage);
+const formatter$1 = fp.formatWithOptions({
+  awareOfUnicodeTokens: true
+});
+const extractRecordingChannel$1 = (stage, track) => R__namespace.pipe(filesByIdView$1, R__namespace.path([track.ref, "metadata", "recChannel"]))(stage);
+const createHighSpeedTracksLabels$1 = stage => tracks => mapWithIndex$1((hs, index) => {
+  const recordingChannel = extractRecordingChannel$1(stage, hs);
+  const no = recordingChannel || index + 1;
+  return R__namespace.assoc("label", `HS ${no}`, hs);
+}, tracks);
+const createVideoTracksLabels$1 = stage => tracks => mapWithIndex$1((vid, index) => {
+  const recordingChannel = extractRecordingChannel$1(stage, vid);
+  const no = recordingChannel || index + 1;
+  return R__namespace.assoc("label", `VID ${no}`, vid);
+}, tracks);
+const extractFormat$1 = (stage, track) => R__namespace.pipe(filesByIdView$1, R__namespace.path([track.ref, "path"]), p => fsPath$1.extname(p))(stage);
+const extractSecondFractions$1 = isoStr => R__namespace.pipe(match$1(/[0-9]{2}:[0-9]{2}:[0-9]{2}.([0-9]+)/), R__namespace.ifElse(R__namespace.isNil, R__namespace.always("000"), R__namespace.nth(1)))(isoStr);
+const extractDate = (stage, track) => {
+  return R__namespace.pipe(filesByIdView$1, R__namespace.path([track.ref, "start"]), fp.parseISO, formatter$1("dd-MM-yyyy"))(stage);
+};
+const createTime$1 = R__namespace.converge(R__namespace.pipe(R__namespace.pair, R__namespace.join(".")), [R__namespace.pipe(fp.parseISO, formatter$1("HH:mm:ss")), extractSecondFractions$1]);
+const extractStart = (stage, track) => R__namespace.pipe(filesByIdView$1, R__namespace.path([track.ref, "start"]), createTime$1)(stage);
+const extractEnd = (stage, track) => R__namespace.pipe(filesByIdView$1, R__namespace.path([track.ref, "end"]), createTime$1)(stage);
+const createVideoMetadata$1 = R__namespace.curry((type, stage, track) => ({
+  ...track,
+  metadata: track.metadata || [[{
+    label: "Test",
+    value: extractTestNumber$1(stage, track)
+  }], [{
+    label: "Type",
+    value: type
+  }, {
+    label: "Recording channel",
+    value: extractRecordingChannel$1(stage, track)
+  }, {
+    label: "Format",
+    value: extractFormat$1(stage, track)
+  }], [{
+    label: "Date",
+    value: extractDate(stage, track)
+  }, {
+    label: "Start",
+    value: extractStart(stage, track)
+  }, {
+    label: "End",
+    value: extractEnd(stage, track)
+  }]]
+}));
+const createHighSpeedsMetadata$1 = R__namespace.curry((stage, tracks) => R__namespace.map(createVideoMetadata$1("high-speed", stage), tracks));
+const createVideosMetadata$1 = R__namespace.curry((stage, tracks) => R__namespace.map(createVideoMetadata$1("video", stage), tracks));
+const createTracks$1 = stage => R__namespace.converge((...args) => R__namespace.flatten(args), [R__namespace.pipe(mapEntitiesToTracks$1(highSpeedsFilesView$1, "high-speed"), createHighSpeedTracksLabels$1(stage), createHighSpeedsMetadata$1(stage)), R__namespace.pipe(mapEntitiesToTracks$1(videosFilesView$1, "video"), createVideoTracksLabels$1(stage), createVideosMetadata$1(stage)), mapCommentsToTracks$1])(stage);
+const upsertTracks$1 = tracks => R__namespace.curry(R__namespace.pipe(R__namespace.unless(R__namespace.path(tracksIdsPath$1), R__namespace.assocPath(tracksIdsPath$1, [])), R__namespace.unless(R__namespace.path(tracksByIdPath$1), R__namespace.assocPath(tracksByIdPath$1, {})), R__namespace.over(tracksIdsLens$1, R__namespace.union(R__namespace.pluck("id", tracks))), R__namespace.over(tracksByIdLens$1, R__namespace.mergeRight(indexById(tracks)))));
+const earliestTime$1 = stage => R__namespace.pipe(filesView, R__namespace.map(R__namespace.prop("start")), R__namespace.map(Date.parse), R__namespace.apply(Math.min), t => new Date(t), d => d.toISOString())(stage);
+const latestTime$1 = stage => R__namespace.pipe(filesView, R__namespace.map(R__namespace.prop("end")), R__namespace.map(Date.parse), R__namespace.apply(Math.max), t => new Date(t), d => d.toISOString())(stage);
+const setTimeLineStartEnd$1 = stage => R__namespace.pipe(R__namespace.assocPath(["timeline", "start"], earliestTime$1(stage)), R__namespace.assocPath(["timeline", "end"], latestTime$1(stage)))(stage);
+const setCommentAxis$1 = R__namespace.assocPath(["timeline", "commentAxis"], "comment");
+const consolidateTimeline$1 = stage => {
+  return R__namespace.pipe(upsertAxes$1(axesSettings$1), upsertTracks$1(createTracks$1(stage)), setTimeLineStartEnd$1, setCommentAxis$1)(stage);
+};
+const consolidate$1 = stage => {
+  return consolidateTimeline$1(stage);
+};
+
+const NEW_TEST_REGEX = /^([0-9]{5})_(.+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)_([0-9]+)$/;
+const fsPath = require("path");
+const match = R__namespace.curry((regex, st) => st.match(regex));
+const mapWithIndex = R__namespace.addIndex(R__namespace.map);
+const axesSettings = [{
+  id: "video",
+  color: "#41b51b"
+}, {
+  id: "high-speed",
+  color: "#3318cc"
+}, {
+  id: "comment",
+  color: "red"
+}];
+const tracksIdsPath = ["timeline", "entities", "tracks", "ids"];
+const tracksByIdPath = ["timeline", "entities", "tracks", "byId"];
+const axesIdsPath = ["timeline", "entities", "axes", "ids"];
+const axesByIdPath = ["timeline", "entities", "axes", "byId"];
+const resourcesIdsView = R__namespace.pathOr([], ["resources", "entities", "resources", "ids"]);
+const resourcesByIdView = R__namespace.pathOr({}, ["resources", "entities", "resources", "byId"]);
+const filesIdsView = R__namespace.pathOr([], ["files", "entities", "files", "ids"]);
+const filesByIdView = R__namespace.pathOr({}, ["files", "entities", "files", "byId"]);
+const timingByIdView = R__namespace.pathOr({}, ["timing", "entities", "timing", "byId"]);
+const commentsByIdView = R__namespace.pathOr({}, ["timeline", "entities", "comments", "byId"]);
+const tracksIdsLens = R__namespace.lensPath(tracksIdsPath);
+const tracksByIdLens = R__namespace.lensPath(tracksByIdPath);
+const axesIdsLens = R__namespace.lensPath(axesIdsPath);
+const axesByIdLens = R__namespace.lensPath(axesByIdPath);
+const timingsView = R__namespace.pipe(timingByIdView, R__namespace.values);
+const commentsView = R__namespace.pipe(commentsByIdView, R__namespace.values);
+const highSpeedsFilesView = stage => {
+  const filesById = filesByIdView(stage);
+  const resourcesById = resourcesByIdView(stage);
+  return R__namespace.pipe(
+  // Iterate R.over the resource ids
+  resourcesIdsView,
+  // Filter out all the ids that don't start with high-speed.
+  R__namespace.filter(R__namespace.startsWith("high-speed:")),
+  // Map the remaining resource ids to the files ids in the respective resource object.
+  lookupPathAll(resourcesById, ["props", "files"]),
+  // Flatten the ids so we get a single array containing all the files ids referred
   // to across all high-speed resources.
-  R.flatten, // Map the file ids to file objects.
+  R__namespace.flatten,
+  // Map the file ids to file objects.
   lookupAll(filesById))(stage);
 };
-
 const highSpeedsTimingsView = stage => {
   const timings = timingsView(stage);
-  return R.pipe(highSpeedsFilesView$1, // Map the file ids to file objects.
+  return R__namespace.pipe(highSpeedsFilesView,
+  // Map the file ids to file objects.
   files => files.map(file => timings.find(timing => timing.ref.id === file.id)))(stage);
 };
-
-const videosFilesView$1 = stage => {
-  const filesIds = filesIdsView$1(stage);
-  const filesById = filesByIdView$1(stage);
-  const highSpeedFiles = highSpeedsFilesView$1(stage);
-  return R.pipe(R.without(R.pluck("id", highSpeedFiles)), lookupAll(filesById), R.filter(R.propEq("type", "video")))(filesIds);
+const videosFilesView = stage => {
+  const filesIds = filesIdsView(stage);
+  const filesById = filesByIdView(stage);
+  const highSpeedFiles = highSpeedsFilesView(stage);
+  return R__namespace.pipe(R__namespace.without(R__namespace.pluck("id", highSpeedFiles)), lookupAll(filesById), R__namespace.filter(R__namespace.propEq("video", "type")))(filesIds);
 };
-
 const videoTimingsView = stage => {
   const timings = timingsView(stage);
-  return R.pipe(videosFilesView$1, files => files.map(file => timings.find(timing => timing.ref.id === file.id)))(stage);
+  return R__namespace.pipe(videosFilesView, files => files.map(file => timings.find(timing => timing.ref.id === file.id)))(stage);
 };
-
-const upsertAxes$1 = axes => R.curry(R.pipe(R.unless(R.path(axesIdsPath$1), R.assocPath(axesIdsPath$1, [])), R.unless(R.path(axesByIdPath$1), R.assocPath(axesIdsPath$1, {})), R.over(axesIdsLens$1, R.union(R.pluck("id", axes))), R.over(axesByIdLens$1, R.merge(indexById(axes)))));
-const createTrackFromEntity$1 = R.curry((axis, entity) => {
+const upsertAxes = axes => R__namespace.curry(R__namespace.pipe(R__namespace.unless(R__namespace.path(axesIdsPath), R__namespace.assocPath(axesIdsPath, [])), R__namespace.unless(R__namespace.path(axesByIdPath), R__namespace.assocPath(axesIdsPath, {})), R__namespace.over(axesIdsLens, R__namespace.union(R__namespace.pluck("id", axes))), R__namespace.over(axesByIdLens, R__namespace.mergeRight(indexById(axes)))));
+const createTrackFromEntity = R__namespace.curry((axis, entity) => {
   const {
     start,
     end,
@@ -2512,8 +3323,8 @@ const createTrackFromEntity$1 = R.curry((axis, entity) => {
     timeline: "1"
   };
 });
-const mapEntitiesToTracks$1 = R.curry((entitiesSelector, axis, stage) => R.map(createTrackFromEntity$1(axis), entitiesSelector(stage)));
-const createTrackFromTiming = R.curry((axis, timing) => {
+const mapEntitiesToTracks = R__namespace.curry((entitiesSelector, axis, stage) => R__namespace.map(createTrackFromEntity(axis), entitiesSelector(stage)));
+const createTrackFromTiming = R__namespace.curry((axis, timing) => {
   const {
     start,
     end,
@@ -2536,62 +3347,54 @@ const createTrackFromTiming = R.curry((axis, timing) => {
     timeline: "1"
   };
 });
-const mapTimingsToTracks = R.curry((entitiesSelector, axis, stage) => R.map(createTrackFromTiming(axis), entitiesSelector(stage)));
-const mapCommentsToTracks$1 = R.pipe(mapEntitiesToTracks$1(commentsView$1, "comment"), R.map(R.mergeLeft({
+const mapTimingsToTracks = R__namespace.curry((entitiesSelector, axis, stage) => R__namespace.map(createTrackFromTiming(axis), entitiesSelector(stage)));
+const mapCommentsToTracks = R__namespace.pipe(mapEntitiesToTracks(commentsView, "comment"), R__namespace.map(R__namespace.mergeLeft({
   type: "comment",
   label: "comment"
 })));
-
-const formatTestNo$1 = input => {
-  const [// eslint-disable-next-line no-unused-vars
-  m, project, facility, program, category, test, experiment, measurement] = input.match(NEW_TEST_REGEX$1);
+const formatTestNo = input => {
+  const [
+  // eslint-disable-next-line no-unused-vars
+  m, project, facility, program, category, test, experiment, measurement] = input.match(NEW_TEST_REGEX);
   return `${project}_${program.padStart(2, "0")}${facility}_${category.padStart(2, "0")}_${test.padStart(3, "0")}_${experiment.padStart(3, "0")}_${measurement.padStart(2, "0")}`;
 };
-
-const extractTestNumberFromMetadata$1 = R.pipe(R.path(["metadata", "location", "$id"]), R.when(R.test(NEW_TEST_REGEX$1), formatTestNo$1));
-const extractTestNumberFromFileName$1 = R.compose(R.head, R.defaultTo([undefined]), R.either(match$1(/[0-9]{5}_[0-9]{2}[a-zA-Z]+_[0-9]{2}_[0-9]{3}_[0-9]{3}_[0-9]{2}/), match$1(/[A-Za-z]+[0-9]{5}_[0-9]+_[0-9]+_[0-9]+/)), R.prop("path"));
-
-const extractTestNumber$1 = (stage, track) => R.pipe(filesByIdView$1, R.prop(track.ref.id), R.either(extractTestNumberFromMetadata$1, extractTestNumberFromFileName$1))(stage);
-
-const formatter$1 = fp.formatWithOptions({
+const extractTestNumberFromMetadata = R__namespace.pipe(R__namespace.path(["metadata", "location", "$id"]), R__namespace.when(R__namespace.test(NEW_TEST_REGEX), formatTestNo));
+const extractTestNumberFromFileName = R__namespace.compose(R__namespace.head, R__namespace.defaultTo([undefined]), R__namespace.either(match(/[0-9]{5}_[0-9]{2}[a-zA-Z]+_[0-9]{2}_[0-9]{3}_[0-9]{3}_[0-9]{2}/), match(/[A-Za-z]+[0-9]{5}_[0-9]+_[0-9]+_[0-9]+/)), R__namespace.prop("path"));
+const extractTestNumber = (stage, track) => R__namespace.pipe(filesByIdView, R__namespace.prop(track.ref.id), R__namespace.either(extractTestNumberFromMetadata, extractTestNumberFromFileName))(stage);
+const formatter = fp.formatWithOptions({
   awareOfUnicodeTokens: true
 });
-
-const extractRecordingChannel$1 = (stage, track) => R.pipe(filesByIdView$1, R.path([track.ref.id, "metadata", "recChannel"]))(stage);
-
-const createHighSpeedTracksLabels$1 = stage => tracks => mapWithIndex$1((hs, index) => {
-  const recordingChannel = extractRecordingChannel$1(stage, hs);
+const extractRecordingChannel = (stage, track) => R__namespace.pipe(filesByIdView, R__namespace.path([track.ref.id, "metadata", "recChannel"]))(stage);
+const createHighSpeedTracksLabels = stage => tracks => mapWithIndex((hs, index) => {
+  const recordingChannel = extractRecordingChannel(stage, hs);
   const no = recordingChannel || index + 1;
-  return R.assoc("label", `HS ${no}`, hs);
+  return R__namespace.assoc("label", `HS ${no}`, hs);
 }, tracks);
-
-const createVideoTracksLabels$1 = stage => tracks => mapWithIndex$1((vid, index) => {
-  const recordingChannel = extractRecordingChannel$1(stage, vid);
+const createVideoTracksLabels = stage => tracks => mapWithIndex((vid, index) => {
+  const recordingChannel = extractRecordingChannel(stage, vid);
   const no = recordingChannel || index + 1;
-  return R.assoc("label", `VID ${no}`, vid);
+  return R__namespace.assoc("label", `VID ${no}`, vid);
 }, tracks);
-
-const extractFormat$1 = (stage, track) => R.pipe(filesByIdView$1, R.path([track.ref.id, "path"]), p => fsPath$1.extname(p))(stage);
-
-const extractSecondFractions$1 = isoStr => R.pipe(match$1(/[0-9]{2}:[0-9]{2}:[0-9]{2}.([0-9]+)/), R.ifElse(R.isNil, R.always("000"), R.nth(1)))(isoStr);
-
-const extractDateFromTrack = R.pipe(R.prop("start"), fp.parseISO, formatter$1("dd-MM-yyyy"));
-const createTime$1 = R.converge(R.pipe(R.pair, R.join(".")), [R.pipe(fp.parseISO, formatter$1("HH:mm:ss")), extractSecondFractions$1]);
-const extractStartFromTrack = R.pipe(R.prop("start"), createTime$1);
-const extractEndFromTrack = R.pipe(R.prop("end"), createTime$1);
-const createVideoMetadata$1 = R.curry((type, stage, track) => ({ ...track,
+const extractFormat = (stage, track) => R__namespace.pipe(filesByIdView, R__namespace.path([track.ref.id, "path"]), p => fsPath.extname(p))(stage);
+const extractSecondFractions = isoStr => R__namespace.pipe(match(/[0-9]{2}:[0-9]{2}:[0-9]{2}.([0-9]+)/), R__namespace.ifElse(R__namespace.isNil, R__namespace.always("000"), R__namespace.nth(1)))(isoStr);
+const extractDateFromTrack = R__namespace.pipe(R__namespace.prop("start"), fp.parseISO, formatter("dd-MM-yyyy"));
+const createTime = R__namespace.converge(R__namespace.pipe(R__namespace.pair, R__namespace.join(".")), [R__namespace.pipe(fp.parseISO, formatter("HH:mm:ss")), extractSecondFractions]);
+const extractStartFromTrack = R__namespace.pipe(R__namespace.prop("start"), createTime);
+const extractEndFromTrack = R__namespace.pipe(R__namespace.prop("end"), createTime);
+const createVideoMetadata = R__namespace.curry((type, stage, track) => ({
+  ...track,
   metadata: [[{
     label: "Test",
-    value: extractTestNumber$1(stage, track)
+    value: extractTestNumber(stage, track)
   }], [{
     label: "Type",
     value: type
   }, {
     label: "Recording channel",
-    value: extractRecordingChannel$1(stage, track)
+    value: extractRecordingChannel(stage, track)
   }, {
     label: "Format",
-    value: extractFormat$1(stage, track)
+    value: extractFormat(stage, track)
   }], [{
     label: "Date",
     value: extractDateFromTrack(track)
@@ -2603,41 +3406,33 @@ const createVideoMetadata$1 = R.curry((type, stage, track) => ({ ...track,
     value: extractEndFromTrack(track)
   }]]
 }));
-const createHighSpeedsMetadata$1 = R.curry((stage, tracks) => R.map(createVideoMetadata$1("high-speed", stage), tracks));
-const createVideosMetadata$1 = R.curry((stage, tracks) => R.map(createVideoMetadata$1("video", stage), tracks));
-
-const createTracks$1 = stage => R.converge((...args) => R.flatten(args), [R.pipe(mapTimingsToTracks(highSpeedsTimingsView, "high-speed"), createHighSpeedTracksLabels$1(stage), createHighSpeedsMetadata$1(stage)), R.pipe(mapTimingsToTracks(videoTimingsView, "video"), createVideoTracksLabels$1(stage), createVideosMetadata$1(stage)), mapCommentsToTracks$1])(stage);
-
-const upsertTracks$1 = tracks => stage => {
+const createHighSpeedsMetadata = R__namespace.curry((stage, tracks) => R__namespace.map(createVideoMetadata("high-speed", stage), tracks));
+const createVideosMetadata = R__namespace.curry((stage, tracks) => R__namespace.map(createVideoMetadata("video", stage), tracks));
+const createTracks = stage => R__namespace.converge((...args) => R__namespace.flatten(args), [R__namespace.pipe(mapTimingsToTracks(highSpeedsTimingsView, "high-speed"), createHighSpeedTracksLabels(stage), createHighSpeedsMetadata(stage)), R__namespace.pipe(mapTimingsToTracks(videoTimingsView, "video"), createVideoTracksLabels(stage), createVideosMetadata(stage)), mapCommentsToTracks])(stage);
+const upsertTracks = tracks => stage => {
   const indexedById = indexById(tracks);
-  return R.pipe(R.unless(R.path(tracksIdsPath$1), R.assocPath(tracksIdsPath$1, [])), R.unless(R.path(tracksByIdPath$1), R.assocPath(tracksByIdPath$1, {})), R.over(tracksIdsLens$1, R.union(R.pluck("id", tracks))), R.over(tracksByIdLens$1, R.mergeLeft(indexedById)))(stage);
+  return R__namespace.pipe(R__namespace.unless(R__namespace.path(tracksIdsPath), R__namespace.assocPath(tracksIdsPath, [])), R__namespace.unless(R__namespace.path(tracksByIdPath), R__namespace.assocPath(tracksByIdPath, {})), R__namespace.over(tracksIdsLens, R__namespace.union(R__namespace.pluck("id", tracks))), R__namespace.over(tracksByIdLens, R__namespace.mergeLeft(indexedById)))(stage);
 };
-
-const earliestTime$1 = stage => R.pipe(timingsView, R.map(R.prop("start")), R.map(Date.parse), R.apply(Math.min), t => new Date(t), d => d.toISOString())(stage);
-
-const latestTime$1 = stage => R.pipe(timingsView, R.map(R.prop("end")), R.map(Date.parse), R.apply(Math.max), t => new Date(t), d => d.toISOString())(stage);
-
-const setTimeLineStartEnd$1 = stage => R.pipe(R.assocPath(["timeline", "start"], earliestTime$1(stage)), R.assocPath(["timeline", "end"], latestTime$1(stage)))(stage);
-
-const setCommentAxis$1 = R.assocPath(["timeline", "commentAxis"], "comment");
-
-const consolidateTimeline$1 = stage => {
-  return R.pipe(upsertAxes$1(axesSettings$1), upsertTracks$1(createTracks$1(stage)), setTimeLineStartEnd$1, setCommentAxis$1)(stage);
+const earliestTime = stage => R__namespace.pipe(timingsView, R__namespace.map(R__namespace.prop("start")), R__namespace.map(Date.parse), R__namespace.apply(Math.min), t => new Date(t), d => d.toISOString())(stage);
+const latestTime = stage => R__namespace.pipe(timingsView, R__namespace.map(R__namespace.prop("end")), R__namespace.map(Date.parse), R__namespace.apply(Math.max), t => new Date(t), d => d.toISOString())(stage);
+const setTimeLineStartEnd = stage => R__namespace.pipe(R__namespace.assocPath(["timeline", "start"], earliestTime(stage)), R__namespace.assocPath(["timeline", "end"], latestTime(stage)))(stage);
+const setCommentAxis = R__namespace.assocPath(["timeline", "commentAxis"], "comment");
+const consolidateTimeline = stage => {
+  return R__namespace.pipe(upsertAxes(axesSettings), upsertTracks(createTracks(stage)), setTimeLineStartEnd, setCommentAxis)(stage);
 };
-
-var v3$1 = R.pipe(R.tap(s => {
+var v3 = R.pipe(R.tap(s => {
   console.log("consolidating v3 stage!", s);
-}), consolidateTimeline$1);
+}), consolidateTimeline);
 
 var _consolidators = Object.freeze({
-  2: consolidate,
-  3: v3$1
+  2: consolidate$1,
+  3: v3,
+  4: v3
 });
 
 const _consolidate = consolidators => stage => {
   const version = detectVersion(stage);
   const consolidator = R.propOr(R.always(stage), version, consolidators);
-
   try {
     return {
       stage: consolidator(stage)
@@ -2648,101 +3443,95 @@ const _consolidate = consolidators => stage => {
     };
   }
 };
-var consolidate$1 = _consolidate(_consolidators);
+var consolidate = _consolidate(_consolidators);
 
-const upgradeResources = R.over(R.lensPath(["resources", "entities", "resources", "byId"]), R.map(({
+const upgradeResources = R__namespace.over(R__namespace.lensPath(["resources", "entities", "resources", "byId"]), R__namespace.map(({
   files,
   ...resource
-}) => ({ ...resource,
+}) => ({
+  ...resource,
   props: {
     files
   }
 })));
-const createTimingSlice = R.pipe(R.assocPath(["timing", "entities", "timing"], {
+const createTimingSlice = R__namespace.pipe(R__namespace.assocPath(["timing", "entities", "timing"], {
   ids: [],
   byId: {}
-}), R.assocPath(["timing", "entities", "offset"], {
+}), R__namespace.assocPath(["timing", "entities", "offset"], {
   ids: [],
   byId: {}
 }));
-
 const createFilesTimings = s => {
-  const timings = R.pipe(R.path(["files", "entities", "files"]), R.over(R.lensProp("byId"), R.map(R.pipe(R.pick(["id", "start", "end"]), timing => R.assoc("ref", {
+  const timings = R__namespace.pipe(R__namespace.path(["files", "entities", "files"]), R__namespace.over(R__namespace.lensProp("byId"), R__namespace.map(R__namespace.pipe(R__namespace.pick(["id", "start", "end"]), timing => R__namespace.assoc("ref", {
     id: timing.id,
     type: "file"
   }, timing)))))(s);
-  return R.pipe(R.over(R.lensPath(["files", "entities", "files", "byId"]), R.map(R.omit(["start", "end"]))), R.over(R.lensPath(["timing", "entities", "timing"]), R.mergeDeepRight(timings)), R.over(R.lensPath(["timing", "entities", "timing"]), entities => R.assoc("ids", R.keys(entities.byId), entities)))(s);
+  return R__namespace.pipe(R__namespace.over(R__namespace.lensPath(["files", "entities", "files", "byId"]), R__namespace.map(R__namespace.omit(["start", "end"]))), R__namespace.over(R__namespace.lensPath(["timing", "entities", "timing"]), R__namespace.mergeDeepRight(timings)), R__namespace.over(R__namespace.lensPath(["timing", "entities", "timing"]), entities => R__namespace.assoc("ids", R__namespace.keys(entities.byId), entities)))(s);
 };
-
-const createComments = R.unless(R.pipe(R.path(["timeline", "entities", "comments"]), R.complement(R.isNil)), R.assocPath(["timeline", "entities", "comments"], {
+const createComments = R__namespace.unless(R__namespace.pipe(R__namespace.path(["timeline", "entities", "comments"]), R__namespace.complement(R__namespace.isNil)), R__namespace.assocPath(["timeline", "entities", "comments"], {
   ids: [],
   byId: {}
 }));
-
 const createCommentsTimings = s => {
-  const timings = R.pipe(R.path(["timeline", "entities", "comments"]), R.over(R.lensProp("byId"), R.map(R.pipe(R.pick(["id", "start", "end"]), timing => R.assoc("ref", {
+  const timings = R__namespace.pipe(R__namespace.path(["timeline", "entities", "comments"]), R__namespace.over(R__namespace.lensProp("byId"), R__namespace.map(R__namespace.pipe(R__namespace.pick(["id", "start", "end"]), timing => R__namespace.assoc("ref", {
     id: timing.id,
     type: "comment"
   }, timing)))))(s);
-  return R.pipe(R.over(R.lensPath(["timeline", "entities", "comments", "byId"]), R.map(R.omit(["start", "end"]))), R.over(R.lensPath(["timing", "entities", "timing"]), R.mergeDeepRight(timings)), R.over(R.lensPath(["timing", "entities", "timing"]), entities => R.assoc("ids", R.keys(entities.byId), entities)))(s);
+  return R__namespace.pipe(R__namespace.over(R__namespace.lensPath(["timeline", "entities", "comments", "byId"]), R__namespace.map(R__namespace.omit(["start", "end"]))), R__namespace.over(R__namespace.lensPath(["timing", "entities", "timing"]), R__namespace.mergeDeepRight(timings)), R__namespace.over(R__namespace.lensPath(["timing", "entities", "timing"]), entities => R__namespace.assoc("ids", R__namespace.keys(entities.byId), entities)))(s);
 };
-
-const removeOutlets = s => {
-  const outlets = R.path(["data", "entities", "outlets"], s);
-
+const removeOutlets$1 = s => {
+  const outlets = R__namespace.path(["data", "entities", "outlets"], s);
   if (outlets) {
-    return R.pipe(R.dissocPath(["data", "entities", "outlets"]), R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.map(({
+    return R__namespace.pipe(R__namespace.dissocPath(["data", "entities", "outlets"]), R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.map(({
       outletId,
       ...dataViewer
     }) => {
-      const outlet = R.path(["byId", outletId], outlets) || {
+      const outlet = R__namespace.path(["byId", outletId], outlets) || {
         streams: []
       };
-      return { ...dataViewer,
+      return {
+        ...dataViewer,
         streams: outlet.streams
       };
     })))(s);
   }
-
   return s;
 };
-
 const createSliceEntities = entityName => slice => {
-  const result = R.pipe(R.unless(R.has("entities"), R.assoc("entities", {})), R.unless(R.hasPath(["entities", entityName]), R.assocPath(["entities", entityName], {
+  const result = R__namespace.pipe(R__namespace.unless(R__namespace.has("entities"), R__namespace.assoc("entities", {})), R__namespace.unless(R__namespace.hasPath(["entities", entityName]), R__namespace.assocPath(["entities", entityName], {
     ids: [],
     byId: {}
   })))(slice);
   return result;
 };
-
 const createTimelineSlice = s => {
-  return R.pipe(R.over(R.lensProp("timeline"), R.pipe(createSliceEntities("axes"), createSliceEntities("groups"), createSliceEntities("timeline"), createSliceEntities("tracks"))))(s);
+  return R__namespace.pipe(R__namespace.over(R__namespace.lensProp("timeline"), R__namespace.pipe(createSliceEntities("axes"), createSliceEntities("groups"), createSliceEntities("timeline"), createSliceEntities("tracks"))))(s);
 };
-
 const createTimelineGroups = s => {
-  const groups = R.pipe(R.path(["timeline", "entities", "axes"]), R.over(R.lensProp("byId"), R.map(R.dissoc("resources"))))(s);
-  return R.pipe(R.dissocPath(["timeline", "entities", "axes"]), R.assocPath(["timeline", "entities", "groups"], groups))(s);
+  const groups = R__namespace.pipe(R__namespace.path(["timeline", "entities", "axes"]), R__namespace.over(R__namespace.lensProp("byId"), R__namespace.map(R__namespace.dissoc("resources"))))(s);
+  return R__namespace.pipe(R__namespace.dissocPath(["timeline", "entities", "axes"]), R__namespace.assocPath(["timeline", "entities", "groups"], groups))(s);
 };
-
-const createTimeline = s => R.pipe(R.assocPath(["timeline", "entities", "timeline", "byId", "1"], {
+const createTimeline = s => R__namespace.pipe(R__namespace.assocPath(["timeline", "entities", "timeline", "byId", "1"], {
   id: "1",
   groupOrder: ["video", "high-speed", "comment"],
   actions: {
     copyLink: true,
     addComment: true
   },
-  start: R.path(["timeline", "start"], s),
-  end: R.path(["timeline", "end"], s)
-}), R.dissocPath(["timeline", "start"]), R.dissocPath(["timeline", "end"]), R.assocPath(["timeline", "entities", "timeline", "ids"], ["1"]), R.over(R.lensPath(["timeline", "entities", "tracks", "byId"]), R.map(R.pipe(R.assoc("timeline", "1")))), R.assocPath(["timeline", "masterTimeline"], "1"))(s);
-
-const fixTracks = s => R.pipe(R.over(R.lensPath(["timeline", "entities", "tracks", "byId"]), R.map(({
+  start: R__namespace.path(["timeline", "start"], s),
+  end: R__namespace.path(["timeline", "end"], s)
+}), R__namespace.dissocPath(["timeline", "start"]), R__namespace.dissocPath(["timeline", "end"]), R__namespace.assocPath(["timeline", "entities", "timeline", "ids"], ["1"]), R__namespace.over(R__namespace.lensPath(["timeline", "entities", "tracks", "byId"]), R__namespace.map(R__namespace.pipe(R__namespace.assoc("timeline", "1")))), R__namespace.assocPath(["timeline", "masterTimeline"], "1"))(s);
+const fixTracks = s => R__namespace.pipe(R__namespace.over(R__namespace.lensPath(["timeline", "entities", "tracks", "byId"]),
+// eslint-disable-next-line no-unused-vars
+R__namespace.map(({
   axisRef,
   type,
   ref,
   start,
   end,
   ...track
-}) => ({ ...track,
+}) => ({
+  ...track,
   group: axisRef,
   ref: {
     type: type === "video" || type === "image" ? "file" : type,
@@ -2751,16 +3540,15 @@ const fixTracks = s => R.pipe(R.over(R.lensPath(["timeline", "entities", "tracks
   editable: type === "comment",
   timeline: "1"
 }))))(s);
-
-const dataStreamsToMeasurements = s => {
-  const streamsSlice = R.path(["data", "entities", "dataStreams"], s);
-
-  if (!R.isEmpty(streamsSlice) && !R.isNil(streamsSlice)) {
-    const measurementsSlice = R.pipe(R.over(R.lensProp("byId"), R.pipe(R.map(measurement => ({ ...measurement,
+const dataStreamsToMeasurements$1 = s => {
+  const streamsSlice = R__namespace.path(["data", "entities", "dataStreams"], s);
+  if (!R__namespace.isEmpty(streamsSlice) && !R__namespace.isNil(streamsSlice)) {
+    const measurementsSlice = R__namespace.pipe(R__namespace.over(R__namespace.lensProp("byId"), R__namespace.pipe(R__namespace.map(measurement => ({
+      ...measurement,
       legacy: true,
       name: measurement.id
     })))))(streamsSlice);
-    return R.pipe(R.dissocPath(["data", "entities", "dataStreams"]), R.assocPath(["data", "entities", "measurements"], measurementsSlice), R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.map(({
+    return R__namespace.pipe(R__namespace.dissocPath(["data", "entities", "dataStreams"]), R__namespace.assocPath(["data", "entities", "measurements"], measurementsSlice), R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.map(({
       streams = [],
       ...dataViewer
     }) => ({
@@ -2768,69 +3556,234 @@ const dataStreamsToMeasurements = s => {
       ...dataViewer
     }))))(s);
   }
-
   return s;
 };
-
-const translateComponent = component => {
+const translateComponent$1 = component => {
   switch (component) {
     case "DataViewerComponent":
       return "DataViewerPanel";
-
     case "VideoComponent":
       return "VideoPanel";
-
     case "PlaylistComponent":
       return "PlaylistPanel";
-
     default:
       return component;
   }
 };
-
-const fixPanels = s => {
-  if (R.hasPath(["layout", "entities", "layoutSections", "byId"], s)) {
-    return R.pipe(R.over(R.lensPath(["layout", "entities", "layoutSections", "byId"]), R.unless(R.isNil, R.map(R.when(R.has("component"), R.over(R.lensProp("component"), translateComponent))))))(s);
+const fixPanels$1 = s => {
+  if (R__namespace.hasPath(["layout", "entities", "layoutSections", "byId"], s)) {
+    return R__namespace.pipe(R__namespace.over(R__namespace.lensPath(["layout", "entities", "layoutSections", "byId"]), R__namespace.unless(R__namespace.isNil, R__namespace.map(R__namespace.when(R__namespace.has("component"), R__namespace.over(R__namespace.lensProp("component"), translateComponent$1))))))(s);
   }
-
   return s;
 };
-
-const scaleZoomSteps = stage => {
+const scaleZoomSteps$1 = stage => {
   const {
     measurementScale
   } = stage.data;
-  return R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.unless(R.isNil, R.mapObjIndexed(({
+  return R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.unless(R__namespace.isNil, R__namespace.mapObjIndexed(({
     zoomSteps = [],
     ...rest
-  }) => ({ ...rest,
+  }) => ({
+    ...rest,
     zoomSteps: rest.zoomStepsIsScaled ? zoomSteps : zoomSteps.map(step => step * Math.sqrt(measurementScale))
   }))))(stage);
 };
-
-const updateVersion = R.assoc("version", 3);
-var v2ToV3 = R.pipe(R.tap(stage => {
+const updateVersion$2 = R__namespace.assoc("version", 3);
+var v2ToV3$1 = R__namespace.pipe(R__namespace.tap(stage => {
   console.log("upgrading ", stage, " from 2 to 3");
-}), consolidate$1, R.unless(R.prop("error"), R.pipe(R.prop("stage"), removeOutlets, scaleZoomSteps, dataStreamsToMeasurements, createTimingSlice, createTimelineSlice, createFilesTimings, createComments, createCommentsTimings, createTimelineGroups, createTimeline, fixTracks, updateVersion, fixPanels, upgradeResources)));
+}), consolidate, R__namespace.unless(R__namespace.prop("error"), R__namespace.pipe(R__namespace.prop("stage"), removeOutlets$1, scaleZoomSteps$1, dataStreamsToMeasurements$1, createTimingSlice, createTimelineSlice, createFilesTimings, createComments, createCommentsTimings, createTimelineGroups, createTimeline, fixTracks, updateVersion$2, fixPanels$1, upgradeResources)));
 
-var upgraders = (() => [[2, v1ToV2], [3, v2ToV3]]);
+/**
+ * v3-to-v4 Stage Upgrader
+ *
+ * Converts Golden Layout (v3) to DockView layout (v4).
+ *
+ * Key changes:
+ * - Converts layout.entities.layoutSections (flat structure) to layout.dockviewLayout (hierarchical tree)
+ * - Maps component names: DataViewerComponent → DataViewerPanel, VideoComponent → VideoPanel, etc.
+ * - Converts row/column/stack structure to branch/leaf DockView nodes
+ * - Updates version to 4
+ */
 
-const resolveFrom = stage => detectVersion(stage);
+const DOCKVIEW_HORIZONTAL = "HORIZONTAL";
+const DOCKVIEW_VERTICAL = "VERTICAL";
+const LEGACY_COMPONENT_TO_DOCKVIEW = {
+  DataViewerComponent: "DataViewerPanel",
+  VideoComponent: "VideoPanel",
+  PlaylistComponent: "PlaylistPanel"
+};
+const mapLegacyComponentToDockview = component => {
+  return LEGACY_COMPONENT_TO_DOCKVIEW[component] || component;
+};
+const getSectionId = value => {
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value || "";
+};
+const getSection = (sections, value) => sections[getSectionId(value)];
+const isComponentSection = section => {
+  return Boolean(section) && !["row", "column", "stack"].includes((section === null || section === void 0 ? void 0 : section.type) || "");
+};
+const getRootSection = (content, sections) => {
+  const rootId = getSectionId(content && content[0]);
+  return rootId ? sections[rootId] : undefined;
+};
+const getOrientationForSection = section => {
+  return (section === null || section === void 0 ? void 0 : section.type) === "row" ? DOCKVIEW_HORIZONTAL : DOCKVIEW_VERTICAL;
+};
+const getChildSize = (parent, child) => {
+  if (!parent || !child) {
+    return undefined;
+  }
+  return parent.type === "row" ? child.width : child.height;
+};
+const flattenDirectionalChildren = (section, sections) => {
+  const content = (section === null || section === void 0 ? void 0 : section.content) || [];
+  return content.flatMap(childValue => {
+    const child = getSection(sections, childValue);
+    if ((child === null || child === void 0 ? void 0 : child.type) === section.type) {
+      return flattenDirectionalChildren(child, sections);
+    }
+    return [childValue];
+  });
+};
+const createDockviewPanelState = section => {
+  var _section$props, _section$props2;
+  return {
+    id: section.id,
+    contentComponent: mapLegacyComponentToDockview(section.component || ""),
+    title: ((_section$props = section.props) === null || _section$props === void 0 ? void 0 : _section$props.title) || section.title || section.id,
+    params: {
+      ...section.props,
+      wrapMode: section.wrapMode || ((_section$props2 = section.props) === null || _section$props2 === void 0 ? void 0 : _section$props2.wrapMode) || "over"
+    }
+  };
+};
+const createDockviewGroupId = section => {
+  if (section.type === "stack") {
+    return section.id;
+  }
+  return `${section.id}__group`;
+};
+const createDockviewLeaf = (section, sections) => {
+  const childValues = section.type === "stack" ? section.content || [] : [section.id];
+  const panelIds = childValues.map(getSectionId).filter(panelId => Boolean(sections[panelId]));
+  const activeIndex = Math.max(0, Math.min(section.activeItemIndex || 0, Math.max(panelIds.length - 1, 0)));
+  return {
+    type: "leaf",
+    data: {
+      id: createDockviewGroupId(section),
+      views: panelIds,
+      activeView: panelIds[activeIndex]
+    }
+  };
+};
+const createDockviewGridNode = (section, sections) => {
+  if (!section) {
+    return null;
+  }
+  if (section.type === "stack" || isComponentSection(section)) {
+    return createDockviewLeaf(section, sections);
+  }
+  const childValues = flattenDirectionalChildren(section, sections);
+  const children = childValues.map(childValue => {
+    const childSection = getSection(sections, childValue);
+    const node = createDockviewGridNode(childSection, sections);
+    if (!node) {
+      return null;
+    }
+    return {
+      ...node,
+      size: getChildSize(section, childSection)
+    };
+  }).filter(n => n !== null);
+  if (children.length === 0) {
+    return null;
+  }
+  if (children.length === 1) {
+    return children[0];
+  }
+  return {
+    type: "branch",
+    data: children
+  };
+};
+const filterLayoutSectionsByAssets = (sectionsById, assetsById) => {
+  return R__namespace.pipe(R__namespace.map(section => {
+    const assetId = R__namespace.path(["props", "assetId"], section);
+    if (assetId && !assetsById[assetId]) {
+      return null;
+    }
+    return section;
+  }), R__namespace.filter(R__namespace.identity))(sectionsById);
+};
+const createPanelsById = sections => {
+  return R__namespace.pipe(R__namespace.values, R__namespace.filter(isComponentSection), R__namespace.reduce((acc, section) => {
+    return {
+      ...acc,
+      [section.id]: createDockviewPanelState(section)
+    };
+  }, {}))(sections);
+};
+const convertLegacyLayoutToDockview = stage => {
+  var _rootSection$content;
+  const content = R__namespace.path(["layout", "content"], stage);
+  const rawSections = R__namespace.pathOr({}, ["layout", "entities", "layoutSections", "byId"], stage);
+  const assetsById = R__namespace.pathOr({}, ["assets", "entities", "assets", "byId"], stage);
+  const sections = filterLayoutSectionsByAssets(rawSections, assetsById);
+  const rootSection = getRootSection(content, sections);
+  const rootNode = createDockviewGridNode(rootSection, sections);
+  if (!rootSection || !rootNode) {
+    return null;
+  }
+  return {
+    grid: {
+      root: rootNode,
+      height: 100,
+      width: 100,
+      orientation: getOrientationForSection(rootSection)
+    },
+    panels: createPanelsById(sections),
+    activeGroup: createDockviewGroupId(rootSection.type === "stack" ? rootSection : getSection(sections, (_rootSection$content = rootSection.content) === null || _rootSection$content === void 0 ? void 0 : _rootSection$content[0]) || rootSection)
+  };
+};
+const upgradeToDockviewLayout = stage => {
+  // If already has dockviewLayout, skip conversion
+  if (R__namespace.hasPath(["layout", "dockviewLayout"], stage)) {
+    return stage;
+  }
 
-const resolveTo = to => R.defaultTo(R.last(versions))(to);
+  // If no legacy layout sections, nothing to convert
+  if (!R__namespace.hasPath(["layout", "entities", "layoutSections"], stage)) {
+    return stage;
+  }
+  const dockviewLayout = convertLegacyLayoutToDockview(stage);
 
-const versionsCorrect = (from, to) => R.gte(to, from);
+  // Remove legacy layout structure, keep other layout state
+  return R__namespace.pipe(R__namespace.dissocPath(["layout", "entities"]), R__namespace.dissocPath(["layout", "content"]), R__namespace.assocPath(["layout", "dockviewLayout"], dockviewLayout),
+  // Preserve these layout state properties if they exist
+  R__namespace.when(R__namespace.hasPath(["layout", "focus"]), R__namespace.identity), R__namespace.when(R__namespace.hasPath(["layout", "dragging"]), R__namespace.identity), R__namespace.when(R__namespace.hasPath(["layout", "resizingPanels"]), R__namespace.identity))(stage);
+};
+const updateVersion$1 = R__namespace.assoc("version", 4);
+var v3ToV4 = R__namespace.pipe(R__namespace.tap(stage => {
+  console.log("upgrading ", stage, " from 3 to 4");
+}), upgradeToDockviewLayout, updateVersion$1);
 
-const upgradePipe = (from, to, stage) => R.pipe(R.filter(([v]) => v > from && v <= to), R.map(R.nth(1)), R.prepend(R.always(stage)), R.apply(R.pipe), R.applyTo(stage))(upgraders());
+var upgraders = () => [[2, v1ToV2], [3, v2ToV3$1], [4, v3ToV4]];
 
-const optionsParser$1 = ({
+const resolveFrom = stage => detectVersion(stage);
+const resolveTo = to => R.defaultTo(R.last(versions))(to);
+const versionsCorrect = (from, to) => R.gte(to, from);
+const upgradePipe = (from, to, stage) => R.pipe(R.filter(([v]) => v > from && v <= to), R.map(R.nth(1)), R.prepend(R.always(stage)), R.apply(R.pipe), R.applyTo(stage))(upgraders());
+const optionsParser = ({
   upgradeFrom: from = undefined,
   upgradeTo: to = undefined
 }) => ({
   from,
   to
 });
-var upgrade = ((stage, options = {}) => {
+var upgrade = (stage, options = {}) => {
   const {
     to = undefined
   } = options;
@@ -2839,18 +3792,16 @@ var upgrade = ((stage, options = {}) => {
   let upgraded = stage;
   let error;
   console.log(`upgrading from ${resolvedFrom} to ${resolvedTo}.`);
-
   if (versionsCorrect(resolvedFrom, resolvedTo)) {
     upgraded = upgradePipe(resolvedFrom, resolvedTo, stage);
   } else {
     error = new Error(`Incorrect version: from: ${resolvedFrom} > to: ${resolvedTo}`);
   }
-
   return {
     stage: upgraded,
     error
   };
-});
+};
 
 var timezoneData = {
   version: "2018g",
@@ -2863,19 +3814,15 @@ const {
   setTimeZone,
   populateTimeZones
 } = require("timezone-support/dist/lookup-convert");
-
 const {
   formatZonedTime
 } = require("timezone-support/dist/parse-format");
-
 populateTimeZones(timezoneData);
 const dateWithoutTimeZoneExp = /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})((\.)([0-9]{0,}))?$/;
 const dateWithWrongSeconds = /^([0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:)([0-9]{3,})((\.[0-9]+)?((Z|(\+|-)([0-9]{2}:[0-9]{2}|[0-9]+))))$/;
 const amsterdam = findTimeZone("Europe/Amsterdam");
-
 const fixDateWithoutTimezone = d => {
   const matches = dateWithoutTimeZoneExp.exec(d);
-
   if (matches) {
     const timeObj = {
       year: matches[1],
@@ -2892,89 +3839,79 @@ const fixDateWithoutTimezone = d => {
     const formattedTimezone = formatZonedTime(withTimezone, "Z");
     return `${formattedDate}T${formattedTime}${milliseconds || ""}${formattedTimezone}`;
   }
-
   return d;
 };
-
 const fixDateWithWrongSeconds = d => {
   const matches = dateWithWrongSeconds.exec(d);
-
   if (matches) {
     const [, rest, seconds, timezone] = matches;
     const newDate = `${rest}${seconds.substring(seconds.length - 2)}${timezone}`;
     return newDate;
   }
-
   return d;
 };
-
-const isIncorrectTime = input => R.both(R.is(String), R.pipe(R.anyPass([R.test(dateWithoutTimeZoneExp), R.test(dateWithWrongSeconds)])))(input);
-
-const fixDates = obj => R.pipe(R.map(R.ifElse(isIncorrectTime, R.pipe(R.tap(x => `${x} is incorrect date`), fixDateWithoutTimezone, fixDateWithWrongSeconds), R.when(R.is(Object), c => fixDates(c)))))(obj);
+const isIncorrectTime = input => R__namespace.both(R__namespace.is(String), R__namespace.pipe(R__namespace.anyPass([R__namespace.test(dateWithoutTimeZoneExp), R__namespace.test(dateWithWrongSeconds)])))(input);
+const fixDates = obj => R__namespace.pipe(R__namespace.map(R__namespace.ifElse(isIncorrectTime, R__namespace.pipe(R__namespace.tap(x => `${x} is incorrect date`), fixDateWithoutTimezone, fixDateWithWrongSeconds), R__namespace.when(R__namespace.is(Object), c => fixDates(c)))))(obj);
 
 const fixDatesWithOptions = (options, stage) => ({
   stage: fixDates(stage)
 });
-
 const validateWithOptions = (options, stage) => {
-  const validated = validate(stage, optionsParser(options));
+  const validated = validate(stage, optionsParser$1(options));
   return validated;
 };
-
-const upgradeWithOptions = (options, stage) => upgrade(stage, optionsParser$1(options));
-
-const consolidateWithOptions = (options, stage) => consolidate$1(stage);
-
-var steps = (() => [fixDatesWithOptions, validateWithOptions, consolidateWithOptions, upgradeWithOptions]);
+const upgradeWithOptions = (options, stage) => upgrade(stage, optionsParser(options));
+const consolidateWithOptions = (options, stage) => consolidate(stage);
+var steps = () => [fixDatesWithOptions, validateWithOptions, consolidateWithOptions, upgradeWithOptions];
 
 const hasError = R.prop("error");
 const doStep = R.curry((options, step, response) => {
   const normalizedStep = R.curry(R.nAry(2, step));
   return R.pipe(R.defaultTo({}), R.unless(hasError, R.pipe(R.prop("stage"), normalizedStep(options))))(response);
 });
-const handler = R.curry((steps, options, stage) => R.pipe(R.defaultTo([]), R.map(doStep(options)), // Map all the steps to a doStep wrapper so they can be piped.
+const handler = R.curry((steps, options, stage) => R.pipe(R.defaultTo([]), R.map(doStep(options)),
+// Map all the steps to a doStep wrapper so they can be piped.
 R.prepend(R.always({
   stage
-})), R.apply(R.pipe), // Create a pipe of all the steps.
+})), R.apply(R.pipe),
+// Create a pipe of all the steps.
 R.applyTo(stage) // Pipe the stage through the steps.
 )(steps));
-var handlerFactory = ((steps, options) => handler(steps, options));
+var handlerFactory = (steps, options) => handler(steps, options);
 
-var defaultOptions = (() => Object.freeze({
+var defaultOptions = () => Object.freeze({
   upgradeFrom: undefined,
   upgradeTo: undefined,
   validateVersion: undefined
-}));
-
-const removeOutlets$1 = s => {
-  const outlets = R.path(["data", "entities", "outlets"], s);
+});
 
+const removeOutlets = s => {
+  const outlets = R__namespace.path(["data", "entities", "outlets"], s);
   if (outlets) {
-    return R.pipe(R.dissocPath(["data", "entities", "outlets"]), R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.map(({
+    return R__namespace.pipe(R__namespace.dissocPath(["data", "entities", "outlets"]), R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.map(({
       outletId,
       ...dataViewer
     }) => {
-      const outlet = R.path(["byId", outletId], outlets) || {
+      const outlet = R__namespace.path(["byId", outletId], outlets) || {
         streams: []
       };
-      return { ...dataViewer,
+      return {
+        ...dataViewer,
         streams: outlet.streams
       };
     })))(s);
   }
-
   return s;
 };
-
-const dataStreamsToMeasurements$1 = s => {
-  const streamsSlice = R.path(["data", "entities", "dataStreams"], s);
-
-  if (!R.isEmpty(streamsSlice) && !R.isNil(streamsSlice)) {
-    const measurementsSlice = R.pipe(R.over(R.lensProp("byId"), R.pipe(R.map(measurement => ({ ...measurement,
+const dataStreamsToMeasurements = s => {
+  const streamsSlice = R__namespace.path(["data", "entities", "dataStreams"], s);
+  if (!R__namespace.isEmpty(streamsSlice) && !R__namespace.isNil(streamsSlice)) {
+    const measurementsSlice = R__namespace.pipe(R__namespace.over(R__namespace.lensProp("byId"), R__namespace.pipe(R__namespace.map(measurement => ({
+      ...measurement,
       legacy: true,
       name: measurement.id
     })))))(streamsSlice);
-    return R.pipe(R.dissocPath(["data", "entities", "dataStreams"]), R.assocPath(["data", "entities", "measurements"], measurementsSlice), R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.map(({
+    return R__namespace.pipe(R__namespace.dissocPath(["data", "entities", "dataStreams"]), R__namespace.assocPath(["data", "entities", "measurements"], measurementsSlice), R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.map(({
       streams = [],
       ...dataViewer
     }) => ({
@@ -2982,64 +3919,56 @@ const dataStreamsToMeasurements$1 = s => {
       ...dataViewer
     }))))(s);
   }
-
   return s;
 };
-
-const translateComponent$1 = component => {
+const translateComponent = component => {
   switch (component) {
     case "DataViewerComponent":
       return "DataViewerPanel";
-
     case "VideoComponent":
       return "VideoPanel";
-
     case "PlaylistComponent":
       return "PlaylistPanel";
-
     default:
       return component;
   }
 };
-
-const fixPanels$1 = s => {
-  if (R.hasPath(["layout", "entities", "layoutSections", "byId"], s)) {
-    return R.pipe(R.over(R.lensPath(["layout", "entities", "layoutSections", "byId"]), R.unless(R.isNil, R.map(R.when(R.has("component"), R.over(R.lensProp("component"), translateComponent$1))))))(s);
+const fixPanels = s => {
+  if (R__namespace.hasPath(["layout", "entities", "layoutSections", "byId"], s)) {
+    return R__namespace.pipe(R__namespace.over(R__namespace.lensPath(["layout", "entities", "layoutSections", "byId"]), R__namespace.unless(R__namespace.isNil, R__namespace.map(R__namespace.when(R__namespace.has("component"), R__namespace.over(R__namespace.lensProp("component"), translateComponent))))))(s);
   }
-
   return s;
 };
-
-const scaleZoomSteps$1 = stage => settings => {
+const scaleZoomSteps = stage => settings => {
   const {
     measurementScale
   } = stage.data;
-  return R.over(R.lensPath(["data", "entities", "dataViewers", "byId"]), R.unless(R.isNil, R.mapObjIndexed(({
+  return R__namespace.over(R__namespace.lensPath(["data", "entities", "dataViewers", "byId"]), R__namespace.unless(R__namespace.isNil, R__namespace.mapObjIndexed(({
     zoomSteps = [],
     ...rest
-  }) => ({ ...rest,
+  }) => ({
+    ...rest,
     zoomSteps: rest.zoomStepsIsScaled ? zoomSteps : zoomSteps.map(step => step * Math.sqrt(measurementScale))
   }))))(settings);
 };
-
-const removeTimeline = R.dissoc("timeline");
-const updateVersion$1 = R.assoc("version", 3);
-var v2ToV3$1 = R.curry((stage, settings) => {
-  return R.pipe(R.tap(s => {
+const removeTimeline = R__namespace.dissoc("timeline");
+const updateVersion = R__namespace.assoc("version", 3);
+var v2ToV3 = R__namespace.curry((stage, settings) => {
+  return R__namespace.pipe(R__namespace.tap(s => {
     console.log("upgrading settings", s, " from 2 to 3");
-  }), R.pipe(removeOutlets$1, dataStreamsToMeasurements$1, updateVersion$1, scaleZoomSteps$1(stage), fixPanels$1, removeTimeline))(settings);
+  }), R__namespace.pipe(removeOutlets, dataStreamsToMeasurements, updateVersion, scaleZoomSteps(stage), fixPanels, removeTimeline))(settings);
 });
 
-var settingsUpgrader = R.curry((stage, settings) => {
-  return R.pipe(R.unless(R.propEq("version", 3), v2ToV3$1(stage)))(settings);
+var settingsUpgrader = R__namespace.curry((stage, settings) => {
+  return R__namespace.pipe(R__namespace.unless(R__namespace.propEq(3, "version"), v2ToV3(stage)))(settings);
 });
 
-const settingsCleaner = R.pipe(R.dissocPath(["timer", "wantedTime"]));
-var settingsHandler = ((stage, settings) => R.pipe(settingsUpgrader(stage), settingsCleaner)(settings));
+const settingsCleaner = R__namespace.pipe(R__namespace.dissocPath(["timer", "wantedTime"]));
+var settingsHandler = (stage, settings) => R__namespace.pipe(settingsUpgrader(stage), settingsCleaner)(settings);
 
 var name = "insync-stage-handler";
-var version = "3.1.1";
-var description$3 = "Handles stages files. This consists of validating, upgrading and consolodating them.";
+var version = "4.0.0-beta.1";
+var description = "Handles stages files. This consists of validating, upgrading and consolodating them.";
 var author = "David Ammeraal (Noterik B.V.)";
 var license = "MIT";
 var main = "dist/library.js";
@@ -3060,39 +3989,52 @@ var scripts = {
 	"lint:fix": "yarn lint --fix"
 };
 var devDependencies = {
-	"@babel/core": "^7.10.5",
-	"@babel/preset-env": "^7.10.4",
-	"@rollup/plugin-babel": "^5.1.0",
+	"@babel/core": "^7.29.7",
+	"@babel/eslint-parser": "^7.25.0",
+	"@babel/preset-env": "^7.29.7",
+	"@eslint/js": "^10.0.1",
+	"@rollup/plugin-babel": "^5.3.1",
 	"@rollup/plugin-json": "^4.1.0",
-	"@rollup/plugin-node-resolve": "^8.4.0",
-	"babel-eslint": "^10.1.0",
-	"babel-jest": "^26.2.0",
-	"babel-plugin-module-resolver": "^4.0.0",
-	eslint: "6.8.0",
-	"eslint-config-airbnb-base": "14.2.0",
-	"eslint-config-prettier": "^6.11.0",
-	"eslint-import-resolver-babel-module": "^5.1.2",
-	"eslint-plugin-import": "2.21.2",
-	"eslint-plugin-jest": "^23.19.0",
-	"eslint-plugin-prettier": "^3.1.4",
-	jest: "^24.8.0",
-	prettier: "^2.0.5",
-	rollup: "^2.23.0",
-	"rollup-plugin-eslint": "^7.0.0"
+	"@rollup/plugin-node-resolve": "^16.0.3",
+	"babel-jest": "^30.0.0",
+	"babel-plugin-module-resolver": "^4.1.0",
+	eslint: "^10.0.0",
+	"eslint-config-airbnb-base": "^15.0.0",
+	"eslint-config-prettier": "^10.0.0",
+	"eslint-import-resolver-babel-module": "^5.3.2",
+	"eslint-plugin-import": "^2.32.0",
+	"eslint-plugin-jest": "^29.0.0",
+	"eslint-plugin-prettier": "^5.2.0",
+	globals: "^17.6.0",
+	jest: "^30.0.0",
+	prettier: "^2.8.8",
+	rollup: "^2.80.0"
 };
 var dependencies = {
-	ajv: "^6.9.1",
+	ajv: "^6.15.0",
 	"ajv-keywords": "^3.5.2",
-	"core-js": "^3.6.5",
-	"date-fns": "^2.15.0",
+	"core-js": "^3.49.0",
+	"date-fns": "^4.1.0",
 	"object-hash": "^1.3.1",
-	ramda: "^0.26.1",
+	ramda: "^0.32.0",
 	"timezone-support": "^1.8.1"
 };
+var resolutions = {
+	minimist: "^1.2.8",
+	"ansi-regex": "^5.0.1",
+	"brace-expansion": "^2.0.1",
+	minimatch: "^3.1.4",
+	"path-parse": "^1.0.7",
+	json5: "^2.2.3",
+	picomatch: "^2.3.1",
+	lodash: "^4.17.21",
+	"js-yaml": "^4.1.0",
+	debug: "^4.3.5"
+};
 var pkg = {
 	name: name,
 	version: version,
-	description: description$3,
+	description: description,
 	author: author,
 	license: license,
 	main: main,
@@ -3101,7 +4043,8 @@ var pkg = {
 	files: files,
 	scripts: scripts,
 	devDependencies: devDependencies,
-	dependencies: dependencies
+	dependencies: dependencies,
+	resolutions: resolutions
 };
 
 console.log("inSync StageHandler version", pkg.version);