| import assert from "node:assert/strict"; |
| import fs from "node:fs"; |
| import { |
| acceptedPreviewDisposition, |
| applyCheckpointRevisionSeeds, |
| applyCheckpointRevisionSet, |
| applyReviewEdit, |
| checkpointRevisionChain, |
| checkpointResumeOptions, |
| reviewCountdown, |
| reviewDuration, |
| reviewDurationText, |
| reviewLocalDeadline, |
| reviewPlanScenePrompt, |
| reviewSeed, |
| } from "../web/h3_chain_review_core.mjs"; |
|
|
| const acceptedPin = { |
| runName: "project", clipIndex: 5, token: "batch", revision: "a".repeat(32), |
| }; |
| assert.equal(acceptedPreviewDisposition(acceptedPin, { |
| run_name: "project", clip_index: 4, token: "older", |
| }), "ignore", "an earlier scene cannot replace an accepted preview"); |
| assert.equal(acceptedPreviewDisposition(acceptedPin, { |
| run_name: "project", clip_index: 5, token: "batch", |
| }), "hold", "the accepted batch keeps its selected preview pinned"); |
| assert.equal(acceptedPreviewDisposition(acceptedPin, { |
| run_name: "project", clip_index: 5, token: "new-run", |
| }), "release", "a new run of the same scene may replace the old preview"); |
| assert.equal(acceptedPreviewDisposition(acceptedPin, { |
| run_name: "project", clip_index: 6, token: "next", |
| }), "release", "the next scene releases the accepted preview pin"); |
|
|
| assert.equal(reviewSeed("18446744073709551615"), "18446744073709551615"); |
| assert.throws(() => reviewSeed("18446744073709551616"), /uint64/); |
| assert.deepEqual(reviewDuration("15"), {seconds: 15, length: 362}); |
| assert.equal(reviewDurationText(362), "15.083333"); |
| for (const length of [5, 22, 39, 56, 73, 362, 3592]) { |
| assert.equal(reviewDuration(reviewDurationText(length)).length, length); |
| } |
| assert.throws(() => reviewDuration("0"), /positive/); |
|
|
| assert.equal(reviewPlanScenePrompt({shots: [ |
| {id: "one", prompt: ["First."]}, |
| {id: "two", prompt: ["Second.", "", "CAMERA: Wide."]}, |
| ]}, 2, "two"), "Second.\n\nCAMERA: Wide."); |
| assert.equal(reviewPlanScenePrompt({shots: [ |
| {id: "two", prompt: ["Moved second."]}, |
| {id: "one", prompt: ["Moved first."]}, |
| ]}, 2, "two"), "Moved second.", "scene id wins if the Plan was reordered"); |
| assert.equal(reviewPlanScenePrompt({shots: []}, 1, "missing"), null); |
|
|
| const plan = { |
| prompt_prefix: ["Keep identity."], |
| shots: [ |
| {id: "one", prompt: ["Old one."], seed: "1"}, |
| {id: "two", prompt: ["Old two."], seed: "2"}, |
| ], |
| }; |
| applyReviewEdit(plan, 2, "New two.\n\nCAMERA: Close-up.", "9007199254740993", 56); |
| assert.deepEqual(plan.shots[0].prompt, ["Old one."]); |
| assert.deepEqual(plan.shots[1].prompt, ["New two.", "", "CAMERA: Close-up."]); |
| assert.equal(plan.shots[1].seed, "9007199254740993"); |
| assert.equal(plan.shots[1].length, 56); |
| applyReviewEdit(plan, 1, "", "3"); |
| assert.deepEqual(plan.shots[0].prompt, [""]); |
| assert.equal(plan.shots[0].seed, "3"); |
| assert.throws( |
| () => applyReviewEdit({shots: [{prompt: [""]}]}, 1, "", "4"), |
| /scene prompt or shared prompt/i, |
| ); |
|
|
| assert.deepEqual(reviewCountdown(130, 100_000), {seconds: 30, text: "0:30"}); |
| assert.deepEqual(reviewCountdown(100, 100_001), {seconds: 0, text: "0:00"}); |
| assert.equal(reviewCountdown(null, 0), null); |
| assert.equal(reviewLocalDeadline(null, 100, 100_000), null); |
| assert.equal(reviewLocalDeadline(undefined, 100, 100_000), null); |
| assert.equal(reviewLocalDeadline("", 100, 100_000), null); |
| assert.equal(reviewLocalDeadline(130, 100, 100_000), 130); |
|
|
| assert.deepEqual(checkpointResumeOptions([ |
| {scene: 2, resume_scene: 3, scene_id: "second", ready: true, |
| video: {filename: "second.mp4"}}, |
| {scene: 1, resume_scene: 2, scene_id: "first", ready: true, |
| partial_video: {filename: "partial.mp4"}}, |
| {scene: 3, resume_scene: 4, scene_id: "final", ready: true}, |
| {scene: 1, resume_scene: 2, scene_id: "broken", ready: false}, |
| ], 3), [ |
| {savedScene: 1, resumeScene: 2, sceneId: "first", video: null, |
| partialVideo: {filename: "partial.mp4"}}, |
| {savedScene: 2, resumeScene: 3, sceneId: "second", |
| video: {filename: "second.mp4"}, partialVideo: null}, |
| ]); |
|
|
| const revisionA = "a".repeat(32); |
| const revisionB = "b".repeat(32); |
| const revisionC = "c".repeat(32); |
| assert.deepEqual(checkpointRevisionChain([ |
| {scene: 1, revision: revisionA, active: false, ready: true, |
| created_at: "2026-08-14T09:00:00", seed: "11", size_bytes: 1024}, |
| {scene: 1, revision: revisionB, active: true, ready: true, |
| created_at: "2026-08-14T10:00:00", seed: "12", size_bytes: 2048}, |
| {scene: 2, revision: revisionC, active: true, ready: true, |
| created_at: "2026-08-14T11:00:00", seed: "13", size_bytes: 4096}, |
| {scene: 2, revision: "invalid", active: false, ready: true}, |
| ], 3), [ |
| {scene: 1, revisions: [ |
| {scene: 1, sceneId: "clip_0001", revision: revisionB, active: true, |
| createdAt: "2026-08-14T10:00:00", seed: "12", sizeBytes: 2048, |
| promptPreview: "", video: null}, |
| {scene: 1, sceneId: "clip_0001", revision: revisionA, active: false, |
| createdAt: "2026-08-14T09:00:00", seed: "11", sizeBytes: 1024, |
| promptPreview: "", video: null}, |
| ]}, |
| {scene: 2, revisions: [ |
| {scene: 2, sceneId: "clip_0002", revision: revisionC, active: true, |
| createdAt: "2026-08-14T11:00:00", seed: "13", sizeBytes: 4096, |
| promptPreview: "", video: null}, |
| ]}, |
| ]); |
| assert.deepEqual(checkpointRevisionChain([ |
| {scene: 2, revision: revisionC, active: true, ready: true}, |
| ], 3), [], "a recoverable chain must include every predecessor scene"); |
|
|
| const recoveredPlan = applyCheckpointRevisionSet({ |
| prompt_prefix: ["new prefix"], |
| shots: [ |
| {id: "one", prompt: ["new one"], length: 362, steps: 8, seed: "1", |
| context_length: 39, audio_context_length: 44}, |
| {id: "two", prompt: ["new two"], length: 362, steps: 8, seed: "2", |
| context_length: 39, audio_context_length: 44}, |
| ], |
| }, [ |
| {scene: 1, scene_id: "old_one", scene_prompt: "old one", seed: "101", |
| raw_frames: 345, steps: 6, prompt_prefix: "old prefix", context_length: 0, |
| audio_context_length: 33}, |
| {scene: 2, scene_id: "old_two", scene_prompt: "old two", seed: "102", |
| raw_frames: 328, steps: 7, prompt_prefix: "old prefix"}, |
| ]); |
| assert.deepEqual(recoveredPlan.prompt_prefix, ["old prefix"]); |
| assert.deepEqual(recoveredPlan.shots, [ |
| {id: "old_one", prompt: ["old one"], length: 345, steps: 6, seed: "101", |
| context_length: 0, audio_context_length: 33}, |
| {id: "old_two", prompt: ["old two"], length: 328, steps: 7, seed: "102"}, |
| ]); |
|
|
| const activatedAlternate = applyCheckpointRevisionSet({ |
| prompt_prefix: ["current prefix"], |
| shots: [ |
| {id: "one", prompt: ["current one"], length: 362, steps: 8, |
| seed: "1", lora_route: "d", prompt_seed_mode: "randomize"}, |
| {id: "two", prompt: ["current two"], length: 362, steps: 8, |
| seed: "2", context_spatial_proxy: "rgb_5_6"}, |
| ], |
| }, [ |
| {scene: 1, scene_id: "old_one", scene_prompt: "{template|one}", |
| effective_scene_prompt: "executed one", seed: "101", raw_frames: 345, |
| steps: 6, prompt_prefix: "older prefix", context_length: 0, |
| audio_context_length: 0, continuation_mode: "guide", |
| video_blend_frames: 0, source_reference: "off", |
| generated_continuity: "off", source_audio_target: "off", |
| lora_route: "a", prompt_seed_mode: "fixed", prompt_seed: "9001"}, |
| {scene: 2, scene_id: "old_two", scene_prompt: "{template|two}", |
| effective_scene_prompt: "executed two", seed: "102", raw_frames: 328, |
| steps: 7, prompt_prefix: "tip prefix", context_length: 39, |
| audio_context_length: 39, visual_context_source: "old_one", |
| continuation_mode: "masked_av", video_blend_frames: 2, |
| context_spatial_proxy: "latent_5_6", source_reference: "on", |
| generated_continuity: "on", source_audio_target: "locked", |
| prompt_seed_mode: "randomize"}, |
| ], {useEffectivePrompts: true, useTipSharedPrompt: true}); |
| assert.deepEqual(activatedAlternate.prompt_prefix, ["tip prefix"]); |
| assert.deepEqual(activatedAlternate.shots, [ |
| {id: "old_one", prompt: ["executed one"], length: 345, steps: 6, |
| seed: "101", context_length: 0, audio_context_length: 0, |
| continuation_mode: "guide", video_blend_frames: 0, |
| source_reference: "off", generated_continuity: "off", |
| source_audio_target: "off", lora_route: "a", |
| prompt_seed_mode: "fixed", prompt_seed: "9001"}, |
| {id: "old_two", prompt: ["executed two"], length: 328, steps: 7, |
| seed: "102", context_length: 39, audio_context_length: 39, |
| visual_context_source: "old_one", continuation_mode: "masked_av", |
| video_blend_frames: 2, context_spatial_proxy: "latent_5_6", |
| source_reference: "on", generated_continuity: "on", |
| source_audio_target: "locked", prompt_seed_mode: "randomize"}, |
| ]); |
|
|
| const restoredComposition = applyCheckpointRevisionSet({ |
| prompt_prefix: ["keep"], |
| shots: [ |
| {id:"one", prompt:["one"], length:39, steps:8, seed:"1"}, |
| {id:"two", prompt:["two"], length:39, steps:8, seed:"2"}, |
| {id:"three", prompt:["three"], length:39, steps:8, seed:"3"}, |
| ], |
| }, [{ |
| scene:3, scene_id:"three", scene_prompt:"three", seed:"303", |
| raw_frames:39, steps:9, prompt_prefix:"keep", context_length:39, |
| visual_context_source:"one", visual_context_lead_source:"two", |
| visual_context_start_frame:2, visual_context_lead_frames:5, |
| visual_context_lead_start_frame:3, video_blend_frames:0, |
| }]); |
| assert.equal(restoredComposition.shots[2].visual_context_source, "one"); |
| assert.equal(restoredComposition.shots[2].visual_context_start_frame, 2); |
| assert.equal(restoredComposition.shots[2].visual_context_lead_source, "two"); |
| assert.equal(restoredComposition.shots[2].visual_context_lead_frames, 5); |
| assert.equal(restoredComposition.shots[2].visual_context_lead_start_frame, 3); |
|
|
| const restoredSameSource = applyCheckpointRevisionSet({ |
| prompt_prefix: ["keep"], |
| shots: [ |
| {id:"one", prompt:["one"], length:39, steps:8, seed:"1"}, |
| {id:"two", prompt:["two"], length:39, steps:8, seed:"2"}, |
| {id:"three", prompt:["three"], length:39, steps:8, seed:"3"}, |
| ], |
| }, [{ |
| scene:3, scene_id:"three", scene_prompt:"three", seed:"303", |
| raw_frames:39, steps:9, prompt_prefix:"keep", context_length:39, |
| visual_context_source:"one", visual_context_lead_source:"one", |
| visual_context_lead_frames:5, video_blend_frames:0, |
| }]); |
| assert.equal(restoredSameSource.shots[2].visual_context_source, "one"); |
| assert.equal(restoredSameSource.shots[2].visual_context_lead_source, "one"); |
|
|
| const restoredBuilder = applyCheckpointRevisionSet({ |
| prompt_prefix:["keep"], |
| shots:[ |
| {id:"one", prompt:["one"], length:90, steps:8, seed:"1"}, |
| {id:"two", prompt:["two"], length:90, steps:8, seed:"2"}, |
| {id:"three", prompt:["three"], length:90, steps:8, seed:"3", |
| visual_context_source:"one"}, |
| ], |
| }, [{ |
| scene:3, scene_id:"three", scene_prompt:"three", seed:"303", |
| raw_frames:90, steps:9, prompt_prefix:"keep", context_length:39, |
| visual_context_blocks:[ |
| {source:"one", frames:5}, |
| {source:"two", frames:12, start_frame:0}, |
| {source:"one", frames:22}, |
| ], video_blend_frames:0, |
| }]); |
| assert.deepEqual(restoredBuilder.shots[2].visual_context_blocks, [ |
| {source:"one", frames:5}, |
| {source:"two", frames:12, start_frame:0}, |
| {source:"one", frames:22}, |
| ]); |
| assert.equal( |
| Object.hasOwn(restoredBuilder.shots[2], "visual_context_source"), false, |
| ); |
|
|
| const seedOnlyPlan = applyCheckpointRevisionSeeds({ |
| prompt_prefix: ["keep prefix"], |
| shots: [ |
| {id: "one", prompt: ["keep one"], length: 362, steps: 8, seed: "1"}, |
| {id: "two", prompt: ["keep two"], length: 345, steps: 6, seed: "2"}, |
| ], |
| }, [ |
| {scene: 1, seed: "101", scene_prompt: "ignored", raw_frames: 5, steps: 1}, |
| {scene: 2, seed: "102", scene_prompt: "ignored", raw_frames: 5, steps: 1}, |
| ]); |
| assert.deepEqual(seedOnlyPlan, { |
| prompt_prefix: ["keep prefix"], |
| shots: [ |
| {id: "one", prompt: ["keep one"], length: 362, steps: 8, seed: "101"}, |
| {id: "two", prompt: ["keep two"], length: 345, steps: 6, seed: "102"}, |
| ], |
| }); |
|
|
| const reviewSource = fs.readFileSync( |
| new URL("../web/h3_chain_review_final.js", import.meta.url), |
| "utf8", |
| ); |
| const backendSource = fs.readFileSync( |
| new URL("../chain_nodes.py", import.meta.url), |
| "utf8", |
| ); |
| assert.match(reviewSource, /minimax_h3_context_loop\/review/); |
| assert.match(reviewSource, /minimax_h3_context_loop_review_resolved/); |
| assert.match(reviewSource, /item\.name === "scene_range"/); |
| assert.match(reviewSource, /rangeWidget\.value = range/); |
| assert.match(reviewSource, /_h3QueuedReview/); |
| assert.match(reviewSource, /setInterval[\s\S]*fetchPending/); |
| assert.match(reviewSource, /addEventListener\("status", fetchPending\)/); |
| assert.match(reviewSource, /async nodeCreated\(node\)/); |
| assert.match(reviewSource, /gates\.length === 1/); |
| assert.match(reviewSource, /data\?\.run_name/); |
| assert.match(reviewSource, /mountedReviewNodes/); |
| assert.match(reviewSource, /split\(\/\[\.:\]\//); |
| assert.match(reviewSource, /No pending review is available for this project yet/); |
| assert.match(reviewSource, /button\.disabled = false/); |
| assert.doesNotMatch( |
| reviewSource, |
| /await fetchPending\(\);\s*return;/, |
| "an action click must continue after recovering its pending token", |
| ); |
| assert.match(reviewSource, /"pointerdown", "pointerup", "mousedown", "mouseup", "click"/); |
| assert.match(reviewSource, /preview_revision/); |
| assert.match(reviewSource, /sameToken/); |
| assert.match( |
| reviewSource, |
| /if \(!sameToken\)[\s\S]*setTimeout\(refreshResumeOptions, 0\)/, |
| "a newly persisted review scene must refresh checkpoint history", |
| ); |
| assert.match( |
| reviewSource, |
| /data\.action === "approve" \|\| data\.action === "stop"[\s\S]*setTimeout\(refreshResumeOptions, 0\)/, |
| "final approval must refresh checkpoint history", |
| ); |
| assert.match(reviewSource, /Checkpoint history/); |
| assert.match(reviewSource, /const refreshToken = \+\+resumeRefreshToken/); |
| assert.match(reviewSource, /if \(refreshToken !== resumeRefreshToken\) return/); |
| assert.match(reviewSource, /candidate_revision/); |
| assert.match(reviewSource, /Generate next candidate/); |
| assert.match(reviewSource, /Accept now & continue/); |
| assert.match(reviewSource, /review_each_candidate/); |
| assert.match(reviewSource, /review-candidate-batch/); |
| assert.match(reviewSource, /candidate_batch_active/); |
| assert.match(reviewSource, /function planRunNameTrusted\(planNode\)/); |
| assert.match(reviewSource, /item\.name === "project_assets"/); |
| assert.match( |
| reviewSource, |
| /if \(planRunNameTrusted\(planNode\)\) \{[\s\S]*actualRun[\s\S]*actualRun !== expectedRun/, |
| "an exact Review Gate must ignore the stale Plan run-name widget when Project Assets owns it", |
| ); |
| assert.match( |
| reviewSource, |
| /const matchingRun = gates\.filter\([\s\S]*if \(!planRunNameTrusted\(planNode\)\) return false/, |
| "run-name fallback routing must not positively match a Project Assets-owned Plan", |
| ); |
| assert.match(reviewSource, /Pause candidate run/); |
| assert.match(reviewSource, /\/api\/jobs\/\$\{encodeURIComponent\(execution\.promptId\)\}\/cancel/); |
| assert.match(reviewSource, /activate_only: true/); |
| assert.match(reviewSource, /action: "finalize"/); |
| assert.match(reviewSource, /await app\.queuePrompt\(0, 1\)/); |
| assert.doesNotMatch(reviewSource, /fetchApi\("\/interrupt"/); |
| assert.match(reviewSource, /candidate_revisions/); |
| assert.match(reviewSource, /keptCandidateRevisions/); |
| assert.match(reviewSource, /h3r-candidate-dots/); |
| assert.match(reviewSource, /moveCandidate/); |
| assert.match(reviewSource, /exact video and audio continuation tensors/); |
| assert.match(reviewSource, /function setReviewVideo/); |
| assert.match(reviewSource, /video\.dataset\.source === source/); |
| assert.match(reviewSource, /const carriedActiveCandidateRevision/); |
| assert.match(reviewSource, /setReviewVideo\(candidate\.video, sameCandidate\)/); |
| assert.match(reviewSource, /pinAcceptedPreview\(submittedReview, submittedCandidate\)/); |
| assert.match(reviewSource, /acceptedDisposition === "ignore"/); |
| assert.match(reviewSource, /if \(acceptedDisposition === "hold"\) showAcceptedPreview\(\)/); |
| const showCandidateStart = reviewSource.indexOf("function showCandidate"); |
| const showCandidateSource = reviewSource.slice( |
| showCandidateStart, |
| reviewSource.indexOf("function renderCandidateDots", showCandidateStart), |
| ); |
| assert.doesNotMatch( |
| showCandidateSource, |
| /video\.load\(\)/, |
| "candidate progress refreshes must not reload the active preview", |
| ); |
| assert.match(reviewSource, /Candidate \$\{candidate\.number\}\/\$\{current\.candidate_count\}/); |
| assert.match( |
| reviewSource, |
| /checkpointRevisionChain\(\s*checkpointRevisions, planClipCount \+ 1/, |
| "checkpoint history must include the final scene, even though it cannot be a resume predecessor", |
| ); |
| assert.match(reviewSource, /revision\.scene < selectedResumeScene/); |
| assert.match(reviewSource, /data\.final_video \?\? data\.partial_video/); |
| assert.match(reviewSource, /final assembled video/); |
| assert.match(reviewSource, /Duration \(s\)/); |
| assert.match(reviewSource, /body\.length/); |
| const submitStart = reviewSource.indexOf("async function submit"); |
| const submitSource = reviewSource.slice( |
| submitStart, |
| reviewSource.indexOf("node._h3ReviewHandler", submitStart), |
| ); |
| assert.match(submitSource, /const submittedToken = submittedReview\.token/); |
| assert.match(submitSource, /const submittedIndex = submittedReview\.clip_index/); |
| assert.match(submitSource, /promptEditedInGate[\s\S]*planScenePrompt/); |
| assert.match(submitSource, /reviewPromptEditorEnabled\(\)/); |
| assert.match(submitSource, /planScenePrompt/); |
| assert.match(submitSource, /token: submittedToken/); |
| assert.match(submitSource, /scene_prompt: submittedPrompt/); |
| assert.match( |
| submitSource, |
| /updatePlan\(\s*node, submittedIndex, acceptedPrompt, body\.seed, body\.length\)/, |
| ); |
| assert.match(reviewSource, /publishCompanionPrompt/); |
| assert.match(reviewSource, /publishPlanCompanionScene/); |
| assert.match(reviewSource, /_h3PromptCompanionSetScenePrompt/); |
| assert.match(reviewSource, /reviewDurationText\(data\.raw_frames\)/); |
| assert.match(reviewSource, /h3r-video-panel/); |
| assert.match(reviewSource, /checkpoint-revisions\/restore/); |
| assert.match(reviewSource, /checkpoint-revisions\/delete-preview/); |
| assert.match(reviewSource, /checkpoint-revisions\/delete/); |
| assert.match(reviewSource, /snapshot: preview\.snapshot/); |
| const checkpointLoadStart = reviewSource.indexOf( |
| 'loadResume.addEventListener("click"', |
| ); |
| const checkpointLoadSource = reviewSource.slice( |
| checkpointLoadStart, |
| reviewSource.indexOf("function stopCountdown", checkpointLoadStart), |
| ); |
| assert.match(checkpointLoadSource, /include_assets: "false"/); |
| assert.match(checkpointLoadSource, /let restoredPolicyInputs = runBody\.policy_inputs/); |
| assert.match(checkpointLoadSource, /restoredPolicyInputs = body\.policy_inputs/); |
| assert.match( |
| checkpointLoadSource, |
| /restoreSavedPlanInputs\(\s*node, runBody\.plan_inputs, restoredPolicyInputs\)/, |
| ); |
| assert.match(reviewSource, /planNode, policyInputs, inputs/); |
| assert.match(reviewSource, /refreshRestoredPlanEditors\(planNode\)/); |
| assert.match( |
| backendSource, |
| /"policy_inputs": archive_policy_inputs\(\{\s*"compatibility": compatibility/, |
| ); |
| assert.match(checkpointLoadSource, /if \(selections\.length\)/); |
| assert.ok( |
| checkpointLoadSource.indexOf("restoreSavedPlanInputs") |
| < checkpointLoadSource.indexOf("prepareResume"), |
| "the complete saved Plan must be restored before Loop Start is armed", |
| ); |
| assert.match(reviewSource, /Permanently delete scene/); |
| assert.match(reviewSource, /Restore & load/); |
| assert.match(reviewSource, /h3r-video-grip/); |
| assert.match(reviewSource, /h3_chain_review_video_height/); |
| assert.match(reviewSource, /h3_chain_review_prompt_height/); |
| assert.match(reviewSource, /promptResizeObserver = new ResizeObserver/); |
| assert.match(reviewSource, /MiniMaxH3ContexLoop\.ReviewGate\.PromptEditor/); |
| assert.match(reviewSource, /Enable prompt editing inside Review Gate/); |
| assert.match(reviewSource, /defaultValue: false/); |
| assert.match(reviewSource, /Prompt editing in Review Gate is disabled by default in 0\.5/); |
| assert.match(reviewSource, /Scene Prompt Editor or Rich Scene Prompt Editor/); |
| assert.match(reviewSource, /promptLabel\.hidden = !enabled/); |
| assert.match(reviewSource, /promptNotice\.hidden = enabled/); |
| assert.match(reviewSource, /_h3ReviewApplyLayout/); |
| assert.match(reviewSource, /nodeType\.prototype\.onConfigure/); |
| assert.match(reviewSource, /setPointerCapture/); |
| assert.match(reviewSource, /visualHeight \/ layoutHeight/); |
| assert.match(reviewSource, /videoPanel\.offsetHeight, true/); |
| assert.doesNotMatch(reviewSource, /\/h3_motion_context\/review/); |
|
|
| console.log("H3 Chain Review editor helpers: ok"); |
|
|
