@remotion/studio 4.0.499 → 4.0.501

package/dist/esm/renderEntry.mjs

@@ -212,7 +212,7 @@ var renderContent = (Root) => {
     renderToDOM(/* @__PURE__ */ jsx("div", {
       children: /* @__PURE__ */ jsx(DelayedSpinner, {})
     }));
-    import("./chunk-pk1zwsn1.js").then(({ StudioInternals }) => {
+    import("./chunk-n1kj09yv.js").then(({ StudioInternals }) => {
       window.remotion_isStudio = true;
       window.remotion_isReadOnlyStudio = true;
       window.remotion_inputProps = "{}";

package/dist/helpers/browser-studio-operations.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserStudioOperations } from '@remotion/studio-shared';
+export declare const BROWSER_STUDIO_OPERATIONS_READY_EVENT = "remotion-browser-studio-operations-ready";
+export declare const getBrowserStudioOperations: () => BrowserStudioOperations | null;

package/dist/helpers/browser-studio-operations.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrowserStudioOperations = exports.BROWSER_STUDIO_OPERATIONS_READY_EVENT = void 0;
+// Browser Studio may be hosted by a different studio-shared version, so this
+// handshake intentionally has no shared runtime import.
+exports.BROWSER_STUDIO_OPERATIONS_READY_EVENT = 'remotion-browser-studio-operations-ready';
+const getBrowserStudioOperations = () => {
+    var _a;
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    return (_a = window.remotion_browserStudio) !== null && _a !== void 0 ? _a : null;
+};
+exports.getBrowserStudioOperations = getBrowserStudioOperations;

package/dist/helpers/calculate-timeline.d.ts

@@ -1,7 +1,7 @@
 import type { OverrideIdToNodePaths, TSequence } from 'remotion';
-import type { TrackWithHash } from './get-timeline-sequence-sort-key';
+import type { TimelineTrackData } from './get-timeline-sequence-sort-key';
 export declare const calculateTimeline: ({ sequences, overrideIdsToNodePaths, compositions, }: {
     sequences: TSequence[];
     overrideIdsToNodePaths: OverrideIdToNodePaths;
     compositions?: readonly import("remotion").AnyComposition[] | undefined;
-}) => TrackWithHash[];
+}) => TimelineTrackData[];

package/dist/helpers/calculate-timeline.js

@@ -5,7 +5,6 @@ const studio_shared_1 = require("@remotion/studio-shared");
 const get_connected_compositions_1 = require("./get-connected-compositions");
 const get_sequence_visible_range_1 = require("./get-sequence-visible-range");
 const get_timeline_nestedness_1 = require("./get-timeline-nestedness");
-const get_timeline_sequence_hash_1 = require("./get-timeline-sequence-hash");
 const get_timeline_sequence_sort_key_1 = require("./get-timeline-sequence-sort-key");
 const sort_by_nonce_history_1 = require("./sort-by-nonce-history");
 const getInheritedLoopDisplay = (sequence, sequences) => {
@@ -52,19 +51,8 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, compositions = [
         }
         return true;
     });
-    const sameHashes = {};
-    const hashesUsedInRoot = {};
-    const cache = {};
     for (let i = 0; i < timelineSequences.length; i++) {
         const sequence = timelineSequences[i];
-        if (!hashesUsedInRoot[sequence.rootId]) {
-            hashesUsedInRoot[sequence.rootId] = [];
-        }
-        const actualHash = (0, get_timeline_sequence_hash_1.getTimelineSequenceHash)(sequence, sortedSequences, hashesUsedInRoot, cache);
-        if (!sameHashes[actualHash]) {
-            sameHashes[actualHash] = [];
-        }
-        sameHashes[actualHash].push(sequence.id);
         const cascadedStart = (0, get_sequence_visible_range_1.getCascadedStart)(sequence, sortedSequences);
         const cascadedStartWithTrim = (0, get_sequence_visible_range_1.getCascadedStartWithTrim)(sequence, sortedSequences);
         const effectiveFrom = sequence.trimBefore === null
@@ -87,7 +75,6 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, compositions = [
                     : sequence.loopDisplay,
             },
             depth: (0, get_timeline_nestedness_1.getTimelineNestedLevel)(sequence, sortedSequences, 0),
-            hash: actualHash,
             cascadedStart,
             cascadedDuration: sequence.duration,
             keyframeDisplayOffset: hasKeyframeRows
@@ -105,26 +92,19 @@ const calculateTimeline = ({ sequences, overrideIdsToNodePaths, compositions = [
                 : null,
         });
     }
-    const uniqueTracks = [];
-    for (const track of tracks) {
-        const existingTrack = uniqueTracks.find((t) => t.hash === track.hash);
-        if (!existingTrack) {
-            const { cascadedDuration, cascadedStart, ...cleanTrack } = track;
-            uniqueTracks.push(cleanTrack);
-        }
-        else if (existingTrack.connectedCompositions === undefined &&
-            track.connectedCompositions !== undefined) {
-            existingTrack.connectedCompositions = track.connectedCompositions;
-        }
-    }
     const nonceRanks = new Map();
     for (let i = 0; i < tracks.length; i++) {
         nonceRanks.set(tracks[i].sequence.id, i);
     }
-    const sortedTracks = uniqueTracks.sort((a, b) => {
-        const sortKeyA = (0, get_timeline_sequence_sort_key_1.getTimelineSequenceSequenceSortKey)(a, tracks, sameHashes, nonceRanks);
-        const sortKeyB = (0, get_timeline_sequence_sort_key_1.getTimelineSequenceSequenceSortKey)(b, tracks, sameHashes, nonceRanks);
+    const sortedTracks = tracks
+        .sort((a, b) => {
+        const sortKeyA = (0, get_timeline_sequence_sort_key_1.getTimelineSequenceSortKey)(a, tracks, nonceRanks);
+        const sortKeyB = (0, get_timeline_sequence_sort_key_1.getTimelineSequenceSortKey)(b, tracks, nonceRanks);
         return sortKeyA.localeCompare(sortKeyB);
+    })
+        .map((track) => {
+        const { cascadedDuration, cascadedStart, ...cleanTrack } = track;
+        return cleanTrack;
     });
     const nodePathIndexCounters = new Map();
     return sortedTracks

package/dist/helpers/client-id.d.ts

@@ -8,6 +8,5 @@ type Context = {
 export declare const StudioServerConnectionCtx: React.Context<Context>;
 export declare const PreviewServerConnection: React.FC<{
     readonly children: React.ReactNode;
-    readonly readOnlyStudio: boolean;
 }>;
 export {};

package/dist/helpers/client-id.js

@@ -53,10 +53,14 @@ exports.StudioServerConnectionCtx = react_1.default.createContext({
         throw new Error('Context not initalized');
     },
 });
-const PreviewServerConnection = ({ children, readOnlyStudio }) => {
+const PreviewServerConnection = ({ children }) => {
     const listeners = (0, react_1.useRef)([]);
+    const latestUndoRedoEvent = (0, react_1.useRef)(undefined);
     const subscribeToEvent = (0, react_1.useCallback)((type, listener) => {
         listeners.current.push({ type, listener });
+        if (type === 'undo-redo-stack-changed' && latestUndoRedoEvent.current) {
+            listener(latestUndoRedoEvent.current);
+        }
         return () => {
             listeners.current = listeners.current.filter((l) => l.type !== type || l.listener !== listener);
         };
@@ -65,9 +69,6 @@ const PreviewServerConnection = ({ children, readOnlyStudio }) => {
         type: 'init',
     });
     (0, react_1.useEffect)(() => {
-        if (readOnlyStudio) {
-            return;
-        }
         const handleEvent = (newEvent) => {
             var _a, _b;
             if (newEvent.type === 'new-input-props' ||
@@ -76,16 +77,20 @@ const PreviewServerConnection = ({ children, readOnlyStudio }) => {
                 (0, url_state_1.reloadUrl)();
             }
             if (newEvent.type === 'init') {
+                latestUndoRedoEvent.current = {
+                    type: 'undo-redo-stack-changed',
+                    undoFile: newEvent.undoFile,
+                    redoFile: newEvent.redoFile,
+                };
                 listeners.current.forEach((l) => {
                     if (l.type === 'undo-redo-stack-changed') {
-                        l.listener({
-                            type: 'undo-redo-stack-changed',
-                            undoFile: newEvent.undoFile,
-                            redoFile: newEvent.redoFile,
-                        });
+                        l.listener(latestUndoRedoEvent.current);
                     }
                 });
             }
+            if (newEvent.type === 'undo-redo-stack-changed') {
+                latestUndoRedoEvent.current = newEvent;
+            }
             if (newEvent.type === 'render-queue-updated') {
                 (_a = context_1.renderJobsRef.current) === null || _a === void 0 ? void 0 : _a.updateRenderJobs(newEvent.queue);
                 for (const job of newEvent.queue) {
@@ -122,7 +127,7 @@ const PreviewServerConnection = ({ children, readOnlyStudio }) => {
             unsubscribeFromEvents();
             unsubscribeFromConnectionState();
         };
-    }, [readOnlyStudio]);
+    }, []);
     const context = (0, react_1.useMemo)(() => {
         return {
             previewServerState: state,

package/dist/helpers/download-blob.d.ts

@@ -0,0 +1 @@
+export declare const downloadBlob: (blob: Blob, filename: string) => void;

package/dist/helpers/download-blob.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBlob = void 0;
+const downloadBlob = (blob, filename) => {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    const cleanFilename = filename.includes('/')
+        ? filename.substring(filename.lastIndexOf('/') + 1)
+        : filename;
+    a.download = cleanFilename;
+    a.click();
+    URL.revokeObjectURL(url);
+};
+exports.downloadBlob = downloadBlob;

package/dist/helpers/get-timeline-sequence-sort-key.d.ts

@@ -6,7 +6,7 @@ export type SequenceNodePathInfo = {
     numberOfSequencesWithThisNodePath: number;
     supportsEffects: boolean;
 };
-type Track = {
+export type TimelineTrackData = {
     sequence: TSequence;
     connectedCompositions?: readonly _InternalTypes['AnyComposition'][];
     depth: number;
@@ -14,15 +14,8 @@ type Track = {
     keyframeDisplayOffset: number;
     sequenceFrameOffset: number;
 };
-export type TrackWithHash = Track & {
-    hash: string;
-};
-export type TrackWithHashAndOriginalTimings = TrackWithHash & {
-    hash: string;
+export type TimelineTrackWithOriginalTimings = TimelineTrackData & {
     cascadedStart: number;
     cascadedDuration: number;
 };
-export declare const getTimelineSequenceSequenceSortKey: (track: TrackWithHash, tracks: TrackWithHash[], sameHashes?: {
-    [hash: string]: string[];
-}, nonceRanks?: Map<string, number>) => string;
-export {};
+export declare const getTimelineSequenceSortKey: (track: TimelineTrackData, tracks: TimelineTrackData[], nonceRanks: Map<string, number>) => string;

package/dist/helpers/get-timeline-sequence-sort-key.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTimelineSequenceSequenceSortKey = void 0;
-const getTimelineSequenceSequenceSortKey = (track, tracks, sameHashes = {}, nonceRanks = new Map()) => {
+exports.getTimelineSequenceSortKey = void 0;
+const getTimelineSequenceSortKey = (track, tracks, nonceRanks) => {
     var _a;
-    const firstSequenceWithSameHash = tracks.find((t) => sameHashes[track.hash].includes(t.sequence.id));
-    const sequenceId = firstSequenceWithSameHash.sequence.id;
-    const rank = (_a = nonceRanks.get(sequenceId)) !== null && _a !== void 0 ? _a : 0;
+    const rank = (_a = nonceRanks.get(track.sequence.id)) !== null && _a !== void 0 ? _a : 0;
     const id = String(rank).padStart(6, '0');
     if (!track.sequence.parent) {
         return id;
@@ -16,12 +14,6 @@ const getTimelineSequenceSequenceSortKey = (track, tracks, sameHashes = {}, nonc
         // may not exist in the `allTracks` array.
         return id;
     }
-    const firstParentWithSameHash = tracks.find((a) => {
-        return sameHashes[parent.hash].includes(a.sequence.id);
-    });
-    if (!firstParentWithSameHash) {
-        throw new Error('could not find parent: ' + track.sequence.parent);
-    }
-    return `${(0, exports.getTimelineSequenceSequenceSortKey)(firstParentWithSameHash, tracks, sameHashes, nonceRanks)}-${id}`;
+    return `${(0, exports.getTimelineSequenceSortKey)(parent, tracks, nonceRanks)}-${id}`;
 };
-exports.getTimelineSequenceSequenceSortKey = getTimelineSequenceSequenceSortKey;
+exports.getTimelineSequenceSortKey = getTimelineSequenceSortKey;

package/dist/helpers/inject-css.js

@@ -83,20 +83,22 @@ const makeDefaultGlobalCSS = () => {
 
   input:focus,
   textarea:focus,
-  button:focus:not(.__remotion_input_dragger):not(.__remotion_color_swatch),
+  button:focus:not(.__remotion_input_dragger):not(.__remotion_color_swatch):not(.__remotion-inspector-section-title),
   a:focus {
 	    outline: none;
 	    box-shadow: ${colors_1.FOCUS_BOX_SHADOW};
 	  }
 
   .__remotion-composition-selector-item:focus,
-  .__remotion-inspector-inline-action:focus {
+  .__remotion-inspector-inline-action:focus,
+  .__remotion-inspector-section-title:focus {
     outline: none;
     box-shadow: none;
   }
 
   .__remotion-composition-selector-item:focus-visible,
-  .__remotion-inspector-inline-action:focus-visible {
+  .__remotion-inspector-inline-action:focus-visible,
+  .__remotion-inspector-section-title:focus-visible {
     box-shadow: ${colors_1.FOCUS_BOX_SHADOW};
   }
 

package/dist/helpers/interactivity-enabled.d.ts

@@ -1 +1,2 @@
 export declare const isStudioInteractivityEnabled: () => boolean;
+export declare const isStudioSelectionEnabled: () => boolean;

package/dist/helpers/interactivity-enabled.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStudioInteractivityEnabled = void 0;
+exports.isStudioSelectionEnabled = exports.isStudioInteractivityEnabled = void 0;
 const studio_runtime_config_1 = require("./studio-runtime-config");
-exports.isStudioInteractivityEnabled = studio_runtime_config_1.getStudioInteractivityEnabled;
+const isStudioInteractivityEnabled = () => {
+    return ((0, studio_runtime_config_1.getStudioInteractivityEnabled)() &&
+        (typeof window === 'undefined' || !window.remotion_isReadOnlyStudio));
+};
+exports.isStudioInteractivityEnabled = isStudioInteractivityEnabled;
+exports.isStudioSelectionEnabled = studio_runtime_config_1.getStudioInteractivityEnabled;

package/dist/helpers/is-mac.d.ts

@@ -0,0 +1 @@
+export declare const isMac: boolean;

package/dist/helpers/is-mac.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMac = void 0;
+exports.isMac = typeof window !== 'undefined' && window.navigator.platform.startsWith('Mac');

package/dist/helpers/open-in-editor.d.ts

@@ -1,7 +1,11 @@
 import type { CompositionComponentInfoResponse, SymbolicatedStackFrame } from '@remotion/studio-shared';
-import type { OriginalPosition } from '../error-overlay/react-overlay/utils/get-source-map';
+import type { CodePosition, OriginalPosition } from '../error-overlay/react-overlay/utils/get-source-map';
 export declare const openInEditor: (stack: SymbolicatedStackFrame) => Promise<import("@remotion/studio-shared").OpenInEditorResponse>;
 export declare const openOriginalPositionInEditor: (originalPosition: OriginalPosition) => Promise<void>;
+export declare const openOriginalPositionInEditorAtProperty: ({ originalPosition, property, }: {
+    originalPosition: CodePosition;
+    property: string;
+}) => Promise<void>;
 type ResolvedCompositionComponentInfo = {
     location: CompositionComponentInfoResponse['location'];
     canAddSequence: boolean;

package/dist/helpers/open-in-editor.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openCompositionComponentInEditor = exports.preloadCompositionComponentInfo = exports.loadCompositionComponentInfo = exports.useCachedCompositionComponentInfo = exports.getCachedCompositionComponentInfo = exports.subscribeToCompositionComponentInfo = exports.openOriginalPositionInEditor = exports.openInEditor = void 0;
+exports.openCompositionComponentInEditor = exports.preloadCompositionComponentInfo = exports.loadCompositionComponentInfo = exports.useCachedCompositionComponentInfo = exports.getCachedCompositionComponentInfo = exports.subscribeToCompositionComponentInfo = exports.openOriginalPositionInEditorAtProperty = exports.openOriginalPositionInEditor = exports.openInEditor = void 0;
 const react_1 = require("react");
 const call_api_1 = require("../components/call-api");
+const browser_studio_operations_1 = require("./browser-studio-operations");
 const openInEditor = (stack) => {
     const { originalFileName, originalLineNumber, originalColumnNumber, originalFunctionName, originalScriptCode, } = stack;
     return (0, call_api_1.callApi)('/api/open-in-editor', {
@@ -26,6 +27,24 @@ const openOriginalPositionInEditor = async (originalPosition) => {
     });
 };
 exports.openOriginalPositionInEditor = openOriginalPositionInEditor;
+const openOriginalPositionInEditorAtProperty = async ({ originalPosition, property, }) => {
+    const request = {
+        fileName: originalPosition.source,
+        lineNumber: originalPosition.line,
+        columnNumber: originalPosition.column,
+        search: property,
+    };
+    const browserStudioOperations = (0, browser_studio_operations_1.getBrowserStudioOperations)();
+    const position = browserStudioOperations
+        ? await browserStudioOperations.findInFile(request)
+        : await (0, call_api_1.callApi)('/api/find-in-file', request);
+    await (0, exports.openOriginalPositionInEditor)({
+        source: originalPosition.source,
+        line: position.lineNumber,
+        column: position.columnNumber,
+    });
+};
+exports.openOriginalPositionInEditorAtProperty = openOriginalPositionInEditorAtProperty;
 const componentResolutionCache = new Map();
 const componentResolutionResults = new Map();
 const componentResolutionListeners = new Set();
@@ -50,7 +69,7 @@ const getCachedCompositionComponentInfo = ({ compositionFile, compositionId, })
 };
 exports.getCachedCompositionComponentInfo = getCachedCompositionComponentInfo;
 const useCachedCompositionComponentInfo = ({ compositionFile, compositionId, }) => {
-    return (0, react_1.useSyncExternalStore)(exports.subscribeToCompositionComponentInfo, () => {
+    const result = (0, react_1.useSyncExternalStore)(exports.subscribeToCompositionComponentInfo, () => {
         if (compositionFile === null || compositionId === null) {
             return null;
         }
@@ -59,6 +78,18 @@ const useCachedCompositionComponentInfo = ({ compositionFile, compositionId, })
             compositionId,
         });
     }, () => null);
+    (0, react_1.useEffect)(() => {
+        if (!(0, browser_studio_operations_1.getBrowserStudioOperations)() ||
+            compositionFile === null ||
+            compositionId === null) {
+            return;
+        }
+        (0, exports.preloadCompositionComponentInfo)({
+            compositionFile,
+            compositionId,
+        });
+    }, [compositionFile, compositionId]);
+    return result;
 };
 exports.useCachedCompositionComponentInfo = useCachedCompositionComponentInfo;
 const loadCompositionComponentInfo = async ({ compositionFile, compositionId, }) => {
@@ -71,10 +102,14 @@ const loadCompositionComponentInfo = async ({ compositionFile, compositionId, })
         return existing;
     }
     const promise = (async () => {
-        const body = await (0, call_api_1.callApi)('/api/composition-component-info', {
+        const request = {
             compositionFile,
             compositionId,
-        });
+        };
+        const browserStudioOperations = (0, browser_studio_operations_1.getBrowserStudioOperations)();
+        const body = browserStudioOperations
+            ? await browserStudioOperations.getCompositionComponentInfo(request)
+            : await (0, call_api_1.callApi)('/api/composition-component-info', request);
         const result = {
             location: body.location,
             canAddSequence: body.canAddSequence,

package/dist/helpers/preview-server-events.js

@@ -3,9 +3,13 @@
 /// <reference lib="dom.iterable" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribeToPreviewServerConnectionState = exports.subscribeToPreviewServerEvents = exports.ensurePreviewServerEventSource = void 0;
+const browser_studio_operations_1 = require("./browser-studio-operations");
 let source = null;
+let unsubscribeFromBrowserStudio = null;
+let browserStudioReadyListenerInstalled = false;
 let connectionState = { type: 'init' };
 let lastInitEvent = null;
+let pendingHmrEvent = null;
 const messageListeners = new Set();
 const connectionStateListeners = new Set();
 const notifyConnectionState = () => {
@@ -14,10 +18,37 @@ const notifyConnectionState = () => {
     }
 };
 const dispatch = (event) => {
+    if (event.type === 'init') {
+        lastInitEvent = event;
+        connectionState = {
+            type: 'connected',
+            clientId: event.clientId,
+        };
+        notifyConnectionState();
+    }
+    if (event.type === 'hmr' && messageListeners.size === 0) {
+        pendingHmrEvent = event;
+    }
     for (const listener of messageListeners) {
         listener(event);
     }
 };
+const connectToBrowserStudio = () => {
+    if (unsubscribeFromBrowserStudio) {
+        return true;
+    }
+    const browserStudioOperations = (0, browser_studio_operations_1.getBrowserStudioOperations)();
+    if (!browserStudioOperations) {
+        return false;
+    }
+    if (source) {
+        source.close();
+        source = null;
+    }
+    unsubscribeFromBrowserStudio =
+        browserStudioOperations.subscribeToEvent(dispatch);
+    return true;
+};
 const openEventSource = () => {
     if (source) {
         return;
@@ -26,14 +57,6 @@ const openEventSource = () => {
     source.addEventListener('message', (event) => {
         try {
             const newEvent = JSON.parse(event.data);
-            if (newEvent.type === 'init') {
-                lastInitEvent = newEvent;
-                connectionState = {
-                    type: 'connected',
-                    clientId: newEvent.clientId,
-                };
-                notifyConnectionState();
-            }
             dispatch(newEvent);
         }
         catch (_a) {
@@ -53,7 +76,17 @@ const openEventSource = () => {
     });
 };
 const ensurePreviewServerEventSource = () => {
-    if (typeof window === 'undefined' || typeof EventSource === 'undefined') {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    if (!browserStudioReadyListenerInstalled) {
+        browserStudioReadyListenerInstalled = true;
+        window.addEventListener(browser_studio_operations_1.BROWSER_STUDIO_OPERATIONS_READY_EVENT, connectToBrowserStudio);
+    }
+    if (connectToBrowserStudio()) {
+        return;
+    }
+    if (typeof EventSource === 'undefined') {
         return;
     }
     openEventSource();
@@ -65,6 +98,10 @@ const subscribeToPreviewServerEvents = (listener) => {
     if (lastInitEvent && connectionState.type === 'connected') {
         listener(lastInitEvent);
     }
+    if (pendingHmrEvent) {
+        listener(pendingHmrEvent);
+        pendingHmrEvent = null;
+    }
     return () => {
         messageListeners.delete(listener);
     };

package/dist/helpers/sort-by-nonce-history.js

@@ -25,45 +25,123 @@ const compareNonceHistories = (a, b) => {
     return aLatestEpoch - bLatestEpoch;
 };
 exports.compareNonceHistories = compareNonceHistories;
+// Compare two histories, each pre-collapsed to parallel arrays of epochs and
+// nonces sorted by descending epoch, without rebuilding a Map per comparison.
+// Equivalent to getSharedEpochOrder: both find the newest shared epoch and
+// compare its nonces.
+const sharedEpochOrderFromSorted = (aEpochs, aNonces, bEpochs, bNonces) => {
+    let i = 0;
+    let j = 0;
+    while (i < aEpochs.length && j < bEpochs.length) {
+        const ae = aEpochs[i];
+        const be = bEpochs[j];
+        if (ae === be) {
+            return aNonces[i] - bNonces[j];
+        }
+        if (ae > be) {
+            i++;
+        }
+        else {
+            j++;
+        }
+    }
+    return null;
+};
 const sortItemsByNonceHistory = (items) => {
     const n = items.length;
     if (n <= 1) {
         return items.slice();
     }
-    // Build a pairwise ordering matrix from shared epochs.
-    // order[i][j] < 0 means i before j, > 0 means j before i, null means no direct relationship.
-    const order = Array.from({ length: n }, () => Array(n).fill(null));
+    // Collapse each history once into epoch/nonce arrays sorted by descending
+    // epoch. `new Map(nonce)` keeps the last value per duplicated epoch, matching
+    // getSharedEpochOrder. This removes the per-pair Map/Set construction the
+    // pairwise loop below would otherwise repeat O(n^2) times.
+    const epochsOf = new Array(n);
+    const noncesOf = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const map = new Map(items[i].nonce);
+        const epochs = [...map.keys()].sort((x, y) => y - x);
+        epochsOf[i] = epochs;
+        noncesOf[i] = epochs.map((e) => map.get(e));
+    }
+    // Pairwise "strictly before" relation, stored as bitsets: `before[i]` has
+    // bit j set when i must come before j, `known[i]` has bit j set when the
+    // pair (i, j) is directly determined by a shared epoch. Bitsets let the
+    // transitive closure below combine 32 relationships per word.
+    const words = (n + 31) >> 5;
+    const before = new Uint32Array(n * words);
+    const known = new Uint32Array(n * words);
+    // Direct comparison sign per ordered pair; only read where `known` is set.
+    const sign = new Int8Array(n * n);
     for (let i = 0; i < n; i++) {
         for (let j = i + 1; j < n; j++) {
-            const cmp = getSharedEpochOrder(items[i].nonce, items[j].nonce);
-            order[i][j] = cmp;
-            order[j][i] = cmp !== null ? -cmp : null;
+            const cmp = sharedEpochOrderFromSorted(epochsOf[i], noncesOf[i], epochsOf[j], noncesOf[j]);
+            if (cmp === null) {
+                continue;
+            }
+            known[i * words + (j >> 5)] |= 1 << (j & 31);
+            known[j * words + (i >> 5)] |= 1 << (i & 31);
+            sign[i * n + j] = cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
+            sign[j * n + i] = cmp < 0 ? 1 : cmp > 0 ? -1 : 0;
+            if (cmp < 0) {
+                before[i * words + (j >> 5)] |= 1 << (j & 31);
+            }
+            else if (cmp > 0) {
+                before[j * words + (i >> 5)] |= 1 << (i & 31);
+            }
         }
     }
-    // Compute transitive closure: if i < j and j < k, then i < k.
+    // Transitive closure: if i < k and k < j, then i < j. This is the same
+    // Floyd-Warshall relation as before, but the inner sweep is bitwise
+    // (`before[k] & ~known[i]` finds all reachable j at once). A newly derived
+    // edge is marked known immediately so the first path decides an otherwise
+    // undetermined pair — preserving behavior on the inputs where the pairwise
+    // comparison is intentionally non-transitive.
     for (let k = 0; k < n; k++) {
+        const kBase = k * words;
+        const kWord = k >> 5;
+        const kBit = 1 << (k & 31);
         for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n; j++) {
-                if (order[i][j] === null &&
-                    order[i][k] !== null &&
-                    order[k][j] !== null &&
-                    order[i][k] < 0 &&
-                    order[k][j] < 0) {
-                    order[i][j] = -1;
-                    order[j][i] = 1;
+            if (i === k) {
+                continue;
+            }
+            const iBase = i * words;
+            if ((before[iBase + kWord] & kBit) === 0) {
+                continue; // i is not before k, so k adds nothing for i
+            }
+            for (let w = 0; w < words; w++) {
+                const add = before[kBase + w] & ~known[iBase + w];
+                if (add === 0) {
+                    continue;
+                }
+                before[iBase + w] |= add;
+                known[iBase + w] |= add;
+                // Set the mirror relationship (j after i) for each newly known pair.
+                let bits = add;
+                while (bits !== 0) {
+                    const lowest = bits & -bits;
+                    const j = (w << 5) + (31 - Math.clz32(lowest));
+                    sign[i * n + j] = -1;
+                    known[j * words + (i >> 5)] |= 1 << (i & 31);
+                    sign[j * n + i] = 1;
+                    bits ^= lowest;
                 }
             }
         }
     }
-    // Sort using transitive order, falling back to lower latest epoch first.
     const indexMap = new Map(items.map((item, i) => [item, i]));
     const result = items.slice();
     result.sort((a, b) => {
         const ai = indexMap.get(a);
         const bi = indexMap.get(b);
-        const transitiveOrder = order[ai][bi];
-        if (transitiveOrder !== null) {
-            return transitiveOrder;
+        if ((known[ai * words + (bi >> 5)] >> (bi & 31)) & 1) {
+            return sign[ai * n + bi];
+        }
+        if ((before[ai * words + (bi >> 5)] >> (bi & 31)) & 1) {
+            return -1;
+        }
+        if ((before[bi * words + (ai >> 5)] >> (ai & 31)) & 1) {
+            return 1;
         }
         // No transitive relationship — lower latest epoch first
         return a.nonce[a.nonce.length - 1][0] - b.nonce[b.nonce.length - 1][0];