PyPI - seqeyes-python - Versions diffs - 0.2.2__py3-none-any.whl → 0.2.6__py3-none-any.whl - Mend

seqeyes-python 0.2.2py3-none-any.whl → 0.2.6py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

seqeyes/__init__.py +1 -1
seqeyes/_renderer.py +35 -12
seqeyes/resources/pulseq-bundle.js +731 -156
seqeyes/resources/viewer.html +41 -15
{seqeyes_python-0.2.2.dist-info → seqeyes_python-0.2.6.dist-info}/METADATA +13 -3
seqeyes_python-0.2.6.dist-info/RECORD +8 -0
seqeyes_python-0.2.2.dist-info/RECORD +0 -8
{seqeyes_python-0.2.2.dist-info → seqeyes_python-0.2.6.dist-info}/WHEEL +0 -0

seqeyes/__init__.py CHANGED Viewed

@@ -29,4 +29,4 @@ from seqeyes._plot import set, reset
 from seqeyes._renderer import SeqEyesViewer
 __all__ = ["set", "reset", "SeqEyesViewer"]
-__version__ = "0.2.2"
+__version__ = "0.2.6"

seqeyes/_renderer.py CHANGED Viewed

@@ -12,7 +12,7 @@ import base64
 import json
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional, Union
 # ── Paths ─────────────────────────────────────────────────────────────────
@@ -27,6 +27,7 @@ _BUNDLE_CANDIDATES = [
     Path.cwd() / "web" / "pulseq-bundle.js",
 ]
 _VALID_GRAD_UNITS = {"Hz/m", "mT/m", "G/cm"}
+SequenceSource = Union[str, bytes, bytearray, memoryview]
 def _find_bundle() -> str:
@@ -60,7 +61,7 @@ def _normalize_grad_disp(unit: str) -> str:
 def _build_html(
-    seq_text: str,
+    sequence_source: SequenceSource,
     *,
     theme: Optional[str] = None,
     inject_bundle: bool = True,
@@ -74,8 +75,8 @@ def _build_html(
     Parameters
     ----------
-    seq_text : str
-        Raw .seq file content.
+    sequence_source : str or bytes-like
+        Raw text ``.seq`` content or binary ``.bseq`` bytes.
     theme : str or None
         CSS theme class to apply to ``<body>``.
     inject_bundle : bool
@@ -93,7 +94,9 @@ def _build_html(
     """
     template = _read_viewer_template()
     grad_disp = _normalize_grad_disp(grad_disp)
-    seq_b64 = base64.b64encode(seq_text.encode("utf-8")).decode("ascii")
+    source_is_text = isinstance(sequence_source, str)
+    source_bytes = sequence_source.encode("utf-8") if source_is_text else bytes(sequence_source)
+    source_b64 = base64.b64encode(source_bytes).decode("ascii")
     # 1. Inject the pulseq-bundle.js
     bundle_placeholder = "<!-- PULSEQ_BUNDLE_PLACEHOLDER -->"
@@ -108,7 +111,9 @@ def _build_html(
     # 2. Build options injection block (sequence data + display opts)
     opts = [
-        f"window.SEQEYES_RAW_B64 = {json.dumps(seq_b64)};",
+        f"window.SEQEYES_RAW_B64 = {json.dumps(source_b64)};",
+        f"window.SEQEYES_SOURCE_KIND = {json.dumps('text' if source_is_text else 'bytes')};",
+        f"window.SEQEYES_SOURCE_NAME = {json.dumps(label)};",
         f"window.SEQEYES_LABEL = {json.dumps(label)};",
         f"window.SEQEYES_SHOW_BLOCKS = {json.dumps(show_blocks)};",
         f"window.SEQEYES_TIME_RANGE = {json.dumps(list(time_range))};",
@@ -144,8 +149,8 @@ class SeqEyesViewer:
     Parameters
     ----------
-    seq_text : str
-        Raw .seq file content as a string.
+    sequence_source : str or bytes-like
+        Raw text ``.seq`` content or binary ``.bseq`` bytes.
     label : str
         Display label (not yet rendered on the viewer).
     show_blocks : bool
@@ -167,7 +172,7 @@ class SeqEyesViewer:
     def __init__(
         self,
-        seq_text: str,
+        sequence_source: SequenceSource,
         *,
         label: str = "",
         show_blocks: bool = False,
@@ -178,7 +183,9 @@ class SeqEyesViewer:
         width: str = "100%",
         height: str = "550px",
     ) -> None:
-        self._seq_text = seq_text
+        if not isinstance(sequence_source, (str, bytes, bytearray, memoryview)):
+            raise TypeError("sequence_source must be .seq text or .bseq bytes")
+        self._sequence_source = sequence_source
         self._label = label
         self._show_blocks = show_blocks
         self._time_range = time_range
@@ -188,12 +195,28 @@ class SeqEyesViewer:
         self._width = width
         self._height = height
+    @classmethod
+    def from_file(cls, path: Union[str, os.PathLike[str]], **kwargs: Any) -> "SeqEyesViewer":
+        """Create a viewer from a local ``.seq`` or ``.bseq`` file."""
+        source_path = Path(path)
+        if source_path.suffix.lower() not in {".seq", ".bseq"}:
+            raise ValueError("SeqEyesViewer.from_file() expects a .seq or .bseq file")
+        if not source_path.is_file():
+            raise FileNotFoundError(source_path)
+        kwargs.setdefault("label", source_path.name)
+        source: SequenceSource = (
+            source_path.read_text(encoding="utf-8")
+            if source_path.suffix.lower() == ".seq"
+            else source_path.read_bytes()
+        )
+        return cls(source, **kwargs)
     # ── Jupyter integration ───────────────────────────────────────────
     def _repr_html_(self) -> str:
         """Return an HTML iframe that Jupyter renders inline."""
         html = _build_html(
-            self._seq_text,
+            self._sequence_source,
             theme=self._theme,
             label=self._label,
             show_blocks=self._show_blocks,
@@ -231,7 +254,7 @@ class SeqEyesViewer:
     def to_html(self, *, inject_bundle: bool = True) -> str:
         """Return the full standalone HTML string (for saving to a file)."""
         return _build_html(
-            self._seq_text,
+            self._sequence_source,
             theme=self._theme,
             inject_bundle=inject_bundle,
             label=self._label,

seqeyes/resources/pulseq-bundle.js CHANGED Viewed

@@ -30,15 +30,20 @@ var Pulseq = (() => {
     decodeAllBlocks: () => decodeAllBlocks,
     detectSequenceTiming: () => detectSequenceTiming,
     exportKspaceArtifacts: () => exportKspaceArtifacts,
+    exportKspaceArtifactsFromBytes: () => exportKspaceArtifactsFromBytes,
+    exportKspaceArtifactsFromSequence: () => exportKspaceArtifactsFromSequence,
     formatTrajectoryText: () => formatTrajectoryText,
     getTotalDuration: () => getTotalDuration,
+    hasPulseqBinaryMagic: () => hasPulseqBinaryMagic,
     parsePnsHardwareAsc: () => parsePnsHardwareAsc,
+    parseSequenceBinary: () => parseSequenceBinary,
+    parseSequenceBytes: () => parseSequenceBytes,
     parseSequenceText: () => parseSequenceText,
     safePnsModel: () => safePnsModel
   });
   // package.json
-  var version = "0.2.2";
+  var version = "0.2.6";
   // src/pulseq/decompressor.ts
   function decompressShape(compressed, numSamples) {
@@ -103,6 +108,181 @@ var Pulseq = (() => {
     return major * 1e6 + minor * 1e3 + revision;
   }
+  // src/pulseq/readerShared.ts
+  function createEmptySequence() {
+    return {
+      version: { major: 1, minor: 0, revision: 0 },
+      versionCombined: 0,
+      definitions: /* @__PURE__ */ new Map(),
+      definitionsRaw: /* @__PURE__ */ new Map(),
+      blocks: [],
+      rfs: /* @__PURE__ */ new Map(),
+      arbitraryGrads: /* @__PURE__ */ new Map(),
+      trapGrads: /* @__PURE__ */ new Map(),
+      adcs: /* @__PURE__ */ new Map(),
+      extensions: /* @__PURE__ */ new Map(),
+      extensionNames: /* @__PURE__ */ new Map(),
+      extensionTypes: /* @__PURE__ */ new Map(),
+      triggers: [],
+      ncos: [],
+      rotations: [],
+      labelSets: [],
+      labelIncs: [],
+      softDelays: [],
+      rfShims: [],
+      shapes: /* @__PURE__ */ new Map(),
+      rasterTimes: { blockDurationRaster: 1e-5, gradientRaster: 1e-5, rfRaster: 1e-6, adcRaster: 1e-7 }
+    };
+  }
+  function parseError(message) {
+    throw new Error(`Pulseq parse error: ${message}`);
+  }
+  function extensionNameToType(name) {
+    switch (name.toUpperCase()) {
+      case "TRIGGERS":
+        return 1 /* EXT_TRIGGER */;
+      case "ROTATIONS":
+        return 2 /* EXT_ROTATION */;
+      case "LABELSET":
+        return 3 /* EXT_LABELSET */;
+      case "LABELINC":
+        return 4 /* EXT_LABELINC */;
+      case "DELAYS":
+        return 5 /* EXT_DELAY */;
+      case "RF_SHIMS":
+        return 6 /* EXT_RF_SHIM */;
+      case "NCO":
+        return 100 /* EXT_NCO */;
+      default:
+        return 999 /* EXT_UNKNOWN */;
+    }
+  }
+  var KNOWN_LABELS = {
+    "SLC": { labelId: 0, flagId: 0 },
+    "SEG": { labelId: 1, flagId: 0 },
+    "REP": { labelId: 2, flagId: 0 },
+    "AVG": { labelId: 3, flagId: 0 },
+    "ECO": { labelId: 4, flagId: 0 },
+    "PHS": { labelId: 5, flagId: 0 },
+    "SET": { labelId: 6, flagId: 0 },
+    "ACQ": { labelId: 7, flagId: 0 },
+    "LIN": { labelId: 8, flagId: 0 },
+    "PAR": { labelId: 9, flagId: 0 },
+    "ONCE": { labelId: 10, flagId: 0 },
+    "NAV": { labelId: 0, flagId: 1 },
+    "REV": { labelId: 0, flagId: 2 },
+    "SMS": { labelId: 0, flagId: 4 },
+    "REF": { labelId: 0, flagId: 8 },
+    "IMA": { labelId: 0, flagId: 16 },
+    "OFF": { labelId: 0, flagId: 32 },
+    "NOISE": { labelId: 0, flagId: 64 },
+    "PMC": { labelId: 0, flagId: 128 },
+    "NOPOS": { labelId: 0, flagId: 256 },
+    "NOROT": { labelId: 0, flagId: 512 },
+    "NOSCL": { labelId: 0, flagId: 1024 }
+  };
+  var unknownLabelCounter = 0;
+  var unknownLabels = /* @__PURE__ */ new Map();
+  function resetUnknownLabels() {
+    unknownLabelCounter = 0;
+    unknownLabels.clear();
+  }
+  function decodeLabel(name) {
+    const known = KNOWN_LABELS[name];
+    if (known) return known;
+    let id = unknownLabels.get(name);
+    if (id === void 0) {
+      id = 1e3 + unknownLabelCounter++;
+      unknownLabels.set(name, id);
+    }
+    return { labelId: id, flagId: 0 };
+  }
+  function extractRasterTimes(seq) {
+    const set = (key, field) => {
+      const value = seq.definitions.get(key);
+      if (value?.length) seq.rasterTimes[field] = value[0];
+    };
+    set("BlockDurationRaster", "blockDurationRaster");
+    set("GradientRasterTime", "gradientRaster");
+    set("RadiofrequencyRasterTime", "rfRaster");
+    set("AdcRasterTime", "adcRaster");
+  }
+  function validateSequence(seq, seenSections) {
+    if (!seenSections.has("VERSION")) parseError("Required [VERSION] section is missing");
+    if (seq.version.major !== 1 || seq.version.minor > 5) {
+      parseError(`Unsupported Pulseq version ${seq.version.major}.${seq.version.minor}.${seq.version.revision}`);
+    }
+    const version2 = seq.versionCombined > 0 ? seq.versionCombined : makeVersionCombined(seq.version.major, seq.version.minor, seq.version.revision);
+    if (version2 >= VER_PRE_14) {
+      requireNumericDefinition(seq, "AdcRasterTime");
+      requireNumericDefinition(seq, "GradientRasterTime");
+      requireNumericDefinition(seq, "RadiofrequencyRasterTime");
+      requireNumericDefinition(seq, "BlockDurationRaster");
+    }
+    if (version2 >= VER_V15001) {
+      const required = seq.definitionsRaw.get("RequiredExtensions")?.split(/\s+/).filter(Boolean) ?? [];
+      for (const name of required) {
+        if (extensionNameToType(name) === 999 /* EXT_UNKNOWN */) {
+          parseError(`Unknown required extension '${name}'`);
+        }
+      }
+    }
+    if (!seenSections.has("BLOCKS")) parseError("Required [BLOCKS] section is missing");
+    for (const block of seq.blocks) {
+      if (block.rfId > 0 && !seq.rfs.has(block.rfId)) {
+        parseError(`Block ${block.num} references undefined RF event ${block.rfId}`);
+      }
+      for (const [channel, gradId] of [["GX", block.gxId], ["GY", block.gyId], ["GZ", block.gzId]]) {
+        if (gradId > 0 && !seq.arbitraryGrads.has(gradId) && !seq.trapGrads.has(gradId)) {
+          parseError(`Block ${block.num} references undefined ${channel} gradient event ${gradId}`);
+        }
+      }
+      if (block.adcId > 0 && !seq.adcs.has(block.adcId)) {
+        parseError(`Block ${block.num} references undefined ADC event ${block.adcId}`);
+      }
+      if (block.extId > 0 && !seq.extensions.has(block.extId)) {
+        parseError(`Block ${block.num} references undefined extension list ${block.extId}`);
+      }
+    }
+    for (const ext of seq.extensions.values()) {
+      if (ext.nextId > 0 && !seq.extensions.has(ext.nextId)) {
+        parseError(`Extension list ${ext.id} references undefined next extension ${ext.nextId}`);
+      }
+      const type = seq.extensionTypes.get(ext.type) ?? 999 /* EXT_UNKNOWN */;
+      if (type === 999 /* EXT_UNKNOWN */) continue;
+      if (!extensionPayloadExists(seq, type, ext.ref)) {
+        const name = seq.extensionNames.get(ext.type) ?? `type ${ext.type}`;
+        parseError(`Extension list ${ext.id} references undefined ${name} payload ${ext.ref}`);
+      }
+    }
+  }
+  function requireNumericDefinition(seq, name) {
+    const value = seq.definitions.get(name);
+    if (!value || value.length === 0 || !Number.isFinite(value[0])) {
+      parseError(`Required definition ${name} is not present in the file`);
+    }
+  }
+  function extensionPayloadExists(seq, type, ref) {
+    switch (type) {
+      case 1 /* EXT_TRIGGER */:
+        return seq.triggers.some((value) => value.id === ref);
+      case 2 /* EXT_ROTATION */:
+        return seq.rotations.some((value) => value.id === ref);
+      case 3 /* EXT_LABELSET */:
+        return seq.labelSets.some((value) => value.id === ref);
+      case 4 /* EXT_LABELINC */:
+        return seq.labelIncs.some((value) => value.id === ref);
+      case 5 /* EXT_DELAY */:
+        return seq.softDelays.some((value) => value.id === ref);
+      case 6 /* EXT_RF_SHIM */:
+        return seq.rfShims.some((value) => value.id === ref);
+      case 100 /* EXT_NCO */:
+        return seq.ncos.some((value) => value.id === ref);
+      default:
+        return false;
+    }
+  }
   // src/pulseq/reader.ts
   function parseSequenceText(text) {
     const seq = createEmptySequence();
@@ -182,38 +362,10 @@ var Pulseq = (() => {
         break;
     }
   }
-  function createEmptySequence() {
-    return {
-      version: { major: 1, minor: 0, revision: 0 },
-      versionCombined: 0,
-      definitions: /* @__PURE__ */ new Map(),
-      definitionsRaw: /* @__PURE__ */ new Map(),
-      blocks: [],
-      rfs: /* @__PURE__ */ new Map(),
-      arbitraryGrads: /* @__PURE__ */ new Map(),
-      trapGrads: /* @__PURE__ */ new Map(),
-      adcs: /* @__PURE__ */ new Map(),
-      extensions: /* @__PURE__ */ new Map(),
-      extensionNames: /* @__PURE__ */ new Map(),
-      extensionTypes: /* @__PURE__ */ new Map(),
-      triggers: [],
-      ncos: [],
-      rotations: [],
-      labelSets: [],
-      labelIncs: [],
-      softDelays: [],
-      rfShims: [],
-      shapes: /* @__PURE__ */ new Map(),
-      rasterTimes: { blockDurationRaster: 1e-5, gradientRaster: 1e-5, rfRaster: 1e-6, adcRaster: 1e-7 }
-    };
-  }
   function ver(seq) {
     if (seq.versionCombined > 0) return seq.versionCombined;
     return makeVersionCombined(seq.version.major, seq.version.minor, seq.version.revision);
   }
-  function parseError(message) {
-    throw new Error(`Pulseq parse error: ${message}`);
-  }
   function requireFieldCount(section, line, count, allowed) {
     const allowedCounts = Array.isArray(allowed) ? allowed : [allowed];
     if (!allowedCounts.includes(count)) {
@@ -457,8 +609,7 @@ var Pulseq = (() => {
   }
   function parseExtensions(seq, valid) {
     const vc = ver(seq);
-    _unknownLabelCounter = 0;
-    _unknownLabels.clear();
+    resetUnknownLabels();
     let i = 0;
     while (i < valid.length) {
       const line = valid[i].trim();
@@ -518,26 +669,6 @@ var Pulseq = (() => {
       }
     }
   }
-  function extensionNameToType(name) {
-    switch (name.toUpperCase()) {
-      case "TRIGGERS":
-        return 1 /* EXT_TRIGGER */;
-      case "ROTATIONS":
-        return 2 /* EXT_ROTATION */;
-      case "LABELSET":
-        return 3 /* EXT_LABELSET */;
-      case "LABELINC":
-        return 4 /* EXT_LABELINC */;
-      case "DELAYS":
-        return 5 /* EXT_DELAY */;
-      case "RF_SHIMS":
-        return 6 /* EXT_RF_SHIM */;
-      case "NCO":
-        return 100 /* EXT_NCO */;
-      default:
-        return 999 /* EXT_UNKNOWN */;
-    }
-  }
   function parseTriggerSpecs(seq, lines) {
     for (const line of lines) {
       const p = splitFields(line);
@@ -593,42 +724,6 @@ var Pulseq = (() => {
       }
     }
   }
-  var KNOWN_LABELS = {
-    "SLC": { labelId: 0, flagId: 0 },
-    "SEG": { labelId: 1, flagId: 0 },
-    "REP": { labelId: 2, flagId: 0 },
-    "AVG": { labelId: 3, flagId: 0 },
-    "ECO": { labelId: 4, flagId: 0 },
-    "PHS": { labelId: 5, flagId: 0 },
-    "SET": { labelId: 6, flagId: 0 },
-    "ACQ": { labelId: 7, flagId: 0 },
-    "LIN": { labelId: 8, flagId: 0 },
-    "PAR": { labelId: 9, flagId: 0 },
-    "ONCE": { labelId: 10, flagId: 0 },
-    "NAV": { labelId: 0, flagId: 1 },
-    "REV": { labelId: 0, flagId: 2 },
-    "SMS": { labelId: 0, flagId: 4 },
-    "REF": { labelId: 0, flagId: 8 },
-    "IMA": { labelId: 0, flagId: 16 },
-    "OFF": { labelId: 0, flagId: 32 },
-    "NOISE": { labelId: 0, flagId: 64 },
-    "PMC": { labelId: 0, flagId: 128 },
-    "NOPOS": { labelId: 0, flagId: 256 },
-    "NOROT": { labelId: 0, flagId: 512 },
-    "NOSCL": { labelId: 0, flagId: 1024 }
-  };
-  var _unknownLabelCounter = 0;
-  var _unknownLabels = /* @__PURE__ */ new Map();
-  function decodeLabel(name) {
-    const known = KNOWN_LABELS[name];
-    if (known) return known;
-    let id = _unknownLabels.get(name);
-    if (id === void 0) {
-      id = 1e3 + _unknownLabelCounter++;
-      _unknownLabels.set(name, id);
-    }
-    return { labelId: id, flagId: 0 };
-  }
   function parseLabelSpecs(seq, lines, isSet) {
     for (const line of lines) {
       const p = splitFields(line);
@@ -739,90 +834,563 @@ var Pulseq = (() => {
       this.rawCount = 0;
     }
   };
-  function extractRasterTimes(seq) {
-    const set = (key, field) => {
-      const v = seq.definitions.get(key);
-      if (v?.length) seq.rasterTimes[field] = v[0];
-    };
-    set("BlockDurationRaster", "blockDurationRaster");
-    set("GradientRasterTime", "gradientRaster");
-    set("RadiofrequencyRasterTime", "rfRaster");
-    set("AdcRasterTime", "adcRaster");
+  // src/pulseq/binaryReader.ts
+  var PULSEQ_BINARY_VERSION = Object.freeze({ major: 1, minor: 5, revision: 2 });
+  var MAGIC = new Uint8Array([1, 112, 117, 108, 115, 101, 113, 2]);
+  var SECTION_PREFIX = 0xffffffff00000000n;
+  var SECTION = Object.freeze({
+    definitions: SECTION_PREFIX | 1n,
+    blocks: SECTION_PREFIX | 2n,
+    rf: SECTION_PREFIX | 3n,
+    gradients: SECTION_PREFIX | 4n,
+    trapezoids: SECTION_PREFIX | 5n,
+    adc: SECTION_PREFIX | 6n,
+    legacyDelays: SECTION_PREFIX | 7n,
+    shapes: SECTION_PREFIX | 8n,
+    extensions: SECTION_PREFIX | 9n,
+    triggers: SECTION_PREFIX | 10n,
+    labelSet: SECTION_PREFIX | 11n,
+    labelInc: SECTION_PREFIX | 12n,
+    softDelays: SECTION_PREFIX | 13n,
+    rfShims: SECTION_PREFIX | 14n,
+    rotations: SECTION_PREFIX | 15n,
+    signature: SECTION_PREFIX | 0x00ffffffn
+  });
+  var MAX_RECORDS = 1e8;
+  var MAX_STRING_BYTES = 16 * 1024 * 1024;
+  var MAX_SHAPE_SAMPLES = 1e8;
+  var BINARY_LABELS = Object.freeze([
+    "SLC",
+    "SEG",
+    "REP",
+    "AVG",
+    "SET",
+    "ECO",
+    "PHS",
+    "LIN",
+    "PAR",
+    "ACQ",
+    "TRID",
+    "NAV",
+    "REV",
+    "SMS",
+    "REF",
+    "IMA",
+    "OFF",
+    "NOISE",
+    "PMC",
+    "NOROT",
+    "NOPOS",
+    "NOSCL",
+    "ONCE"
+  ]);
+  function hasPulseqBinaryMagic(bytes) {
+    if (bytes.byteLength < MAGIC.byteLength) return false;
+    for (let i = 0; i < MAGIC.byteLength; i++) {
+      if (bytes[i] !== MAGIC[i]) return false;
+    }
+    return true;
+  }
+  function parseSequenceBinary(bytes) {
+    const reader = new BinaryReader(bytes);
+    const magic = reader.bytes(MAGIC.byteLength, "file header");
+    if (!hasPulseqBinaryMagic(magic)) {
+      reader.fail("not a Pulseq binary file", 0);
+    }
+    const seq = createEmptySequence();
+    resetUnknownLabels();
+    seq.version.major = reader.safeInt64("version major");
+    seq.version.minor = reader.safeInt64("version minor");
+    seq.version.revision = reader.safeInt64("version revision");
+    seq.versionCombined = makeVersionCombined(
+      seq.version.major,
+      seq.version.minor,
+      seq.version.revision
+    );
+    assertSupportedVersion(seq, reader);
+    const seenSections = /* @__PURE__ */ new Set(["VERSION"]);
+    while (!reader.eof()) {
+      const sectionOffset = reader.position;
+      const section = reader.uint64("section code");
+      switch (section) {
+        case SECTION.definitions:
+          readDefinitions(reader, seq);
+          seenSections.add("DEFINITIONS");
+          break;
+        case SECTION.blocks:
+          readBlocks(reader, seq);
+          seenSections.add("BLOCKS");
+          break;
+        case SECTION.rf:
+          readRf(reader, seq);
+          seenSections.add("RF");
+          break;
+        case SECTION.gradients:
+          readGradients(reader, seq);
+          seenSections.add("GRADIENTS");
+          break;
+        case SECTION.trapezoids:
+          readTrapezoids(reader, seq);
+          seenSections.add("TRAP");
+          break;
+        case SECTION.adc:
+          readAdc(reader, seq);
+          seenSections.add("ADC");
+          break;
+        case SECTION.legacyDelays:
+          readLegacyDelays(reader);
+          break;
+        case SECTION.shapes:
+          readShapes(reader, seq);
+          seenSections.add("SHAPES");
+          break;
+        case SECTION.extensions:
+          readExtensions(reader, seq);
+          seenSections.add("EXTENSIONS");
+          break;
+        case SECTION.triggers:
+          readTriggers(reader, seq);
+          break;
+        case SECTION.labelSet:
+          readLabels(reader, seq, true);
+          break;
+        case SECTION.labelInc:
+          readLabels(reader, seq, false);
+          break;
+        case SECTION.softDelays:
+          readSoftDelays(reader, seq);
+          break;
+        case SECTION.rfShims:
+          readRfShims(reader, seq);
+          break;
+        case SECTION.rotations:
+          readRotations(reader, seq);
+          break;
+        case SECTION.signature:
+          readSignature(reader, seq, sectionOffset);
+          break;
+        default:
+          reader.fail(`unknown section code 0x${section.toString(16)}`, sectionOffset);
+      }
+    }
+    extractRasterTimes(seq);
+    validateSequence(seq, seenSections);
+    return seq;
   }
-  function validateSequence(seq, seenSections) {
-    if (!seenSections.has("VERSION")) parseError("Required [VERSION] section is missing");
-    if (seq.version.major !== 1 || seq.version.minor > 5) {
-      parseError(`Unsupported Pulseq version ${seq.version.major}.${seq.version.minor}.${seq.version.revision}`);
+  function assertSupportedVersion(seq, reader) {
+    const expected = PULSEQ_BINARY_VERSION;
+    if (seq.version.major !== expected.major || seq.version.minor !== expected.minor || seq.version.revision !== expected.revision) {
+      reader.fail(
+        `unsupported Pulseq binary version ${seq.version.major}.${seq.version.minor}.${seq.version.revision}; expected ${expected.major}.${expected.minor}.${expected.revision}`,
+        MAGIC.byteLength
+      );
     }
-    const vc = ver(seq);
-    if (vc >= VER_PRE_14) {
-      requireNumericDefinition(seq, "AdcRasterTime");
-      requireNumericDefinition(seq, "GradientRasterTime");
-      requireNumericDefinition(seq, "RadiofrequencyRasterTime");
-      requireNumericDefinition(seq, "BlockDurationRaster");
+  }
+  function readDefinitions(reader, seq) {
+    const count = reader.count64("DEFINITIONS count", 9);
+    for (let i = 0; i < count; i++) {
+      const keyLength = reader.length32("DEFINITIONS key length");
+      const key = reader.string(keyLength, "DEFINITIONS key");
+      const valueCount = reader.length32("DEFINITIONS value count", MAX_RECORDS);
+      const valueType = reader.char("DEFINITIONS value type");
+      if (valueType === "f") {
+        reader.requireArray(valueCount, 8, "DEFINITIONS float values");
+        const values = new Array(valueCount);
+        for (let j = 0; j < valueCount; j++) values[j] = reader.float64("DEFINITIONS float value");
+        seq.definitions.set(key, values);
+        seq.definitionsRaw.set(key, values.join(" "));
+      } else if (valueType === "i") {
+        reader.requireArray(valueCount, 4, "DEFINITIONS integer values");
+        const values = new Array(valueCount);
+        for (let j = 0; j < valueCount; j++) values[j] = reader.int32("DEFINITIONS integer value");
+        seq.definitions.set(key, values);
+        seq.definitionsRaw.set(key, values.join(" "));
+      } else if (valueType === "c") {
+        const raw = reader.string(valueCount, "DEFINITIONS character value");
+        const value = raw.endsWith("\0") ? raw.slice(0, -1) : raw;
+        seq.definitions.set(key, []);
+        seq.definitionsRaw.set(key, value);
+      } else {
+        reader.fail(`unknown definition value type '${valueType}'`);
+      }
     }
-    if (vc >= VER_V15001) {
-      const required = seq.definitionsRaw.get("RequiredExtensions")?.split(/\s+/).filter(Boolean) ?? [];
-      for (const name of required) {
-        if (extensionNameToType(name) === 999 /* EXT_UNKNOWN */) {
-          parseError(`Unknown required extension '${name}'`);
-        }
+  }
+  function readBlocks(reader, seq) {
+    const count = reader.count64("BLOCKS count", 32);
+    seq.blocks.length = 0;
+    for (let i = 0; i < count; i++) {
+      seq.blocks.push({
+        num: i + 1,
+        dur: reader.nonNegativeSafeInt64("BLOCKS duration"),
+        rfId: reader.int32("BLOCKS RF id"),
+        gxId: reader.int32("BLOCKS Gx id"),
+        gyId: reader.int32("BLOCKS Gy id"),
+        gzId: reader.int32("BLOCKS Gz id"),
+        adcId: reader.int32("BLOCKS ADC id"),
+        extId: reader.int32("BLOCKS extension id")
+      });
+    }
+  }
+  function readRf(reader, seq) {
+    const count = reader.count64("RF count", 73);
+    seq.rfs.clear();
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("RF id");
+      const amplitude = reader.float64("RF amplitude");
+      const magShapeId = reader.int32("RF magnitude shape id");
+      const phaseShapeId = reader.int32("RF phase shape id");
+      const timeShapeId = reader.int32("RF time shape id");
+      const center = psToUs(reader.safeInt64("RF center"));
+      const delay = psToUsRounded(reader.safeInt64("RF delay"));
+      const freqPPM = reader.float64("RF frequency ppm");
+      const phasePPM = reader.float64("RF phase ppm");
+      const freqOffset = reader.float64("RF frequency offset");
+      const phaseOffset = reader.float64("RF phase offset");
+      const use = reader.char("RF use").toLowerCase();
+      if (!/^[erisu]$/.test(use)) reader.fail(`invalid RF use flag '${use}'`);
+      seq.rfs.set(id, {
+        id,
+        amplitude,
+        magShapeId,
+        phaseShapeId,
+        timeShapeId,
+        center,
+        delay,
+        freqPPM,
+        phasePPM,
+        freqOffset,
+        phaseOffset,
+        phaseModShapeId: 0,
+        use
+      });
+    }
+  }
+  function readGradients(reader, seq) {
+    const count = reader.count64("GRADIENTS count", 44);
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("GRADIENTS id");
+      seq.arbitraryGrads.set(id, {
+        id,
+        amplitude: reader.float64("GRADIENTS amplitude"),
+        first: reader.float64("GRADIENTS first"),
+        last: reader.float64("GRADIENTS last"),
+        shapeId: reader.int32("GRADIENTS shape id"),
+        timeId: reader.int32("GRADIENTS time shape id"),
+        delay: psToUsRounded(reader.safeInt64("GRADIENTS delay"))
+      });
+    }
+  }
+  function readTrapezoids(reader, seq) {
+    const count = reader.count64("TRAP count", 44);
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("TRAP id");
+      seq.trapGrads.set(id, {
+        id,
+        amplitude: reader.float64("TRAP amplitude"),
+        rise: psToUsRounded(reader.safeInt64("TRAP rise")),
+        flat: psToUsRounded(reader.safeInt64("TRAP flat")),
+        fall: psToUsRounded(reader.safeInt64("TRAP fall")),
+        delay: psToUsRounded(reader.safeInt64("TRAP delay"))
+      });
+    }
+  }
+  function readAdc(reader, seq) {
+    const count = reader.count64("ADC count", 64);
+    seq.adcs.clear();
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("ADC id");
+      seq.adcs.set(id, {
+        id,
+        numSamples: reader.nonNegativeSafeInt64("ADC sample count"),
+        dwell: psToNsRounded(reader.safeInt64("ADC dwell")),
+        delay: psToUsRounded(reader.safeInt64("ADC delay")),
+        freqPPM: reader.float64("ADC frequency ppm"),
+        phasePPM: reader.float64("ADC phase ppm"),
+        freqOffset: reader.float64("ADC frequency offset"),
+        phaseOffset: reader.float64("ADC phase offset"),
+        deadTime: 0,
+        discardPre: 0,
+        discardPost: 0,
+        phaseModShapeId: reader.int32("ADC phase shape id")
+      });
+    }
+  }
+  function readLegacyDelays(reader) {
+    const count = reader.count64("legacy DELAYS count", 12);
+    for (let i = 0; i < count; i++) {
+      reader.int32("legacy DELAYS id");
+      reader.safeInt64("legacy DELAYS duration");
+    }
+  }
+  function readShapes(reader, seq) {
+    const count = reader.count64("SHAPES count", 20);
+    seq.shapes.clear();
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("SHAPES id");
+      const numSamples = reader.positiveSafeInt64("SHAPES uncompressed count", MAX_SHAPE_SAMPLES);
+      const packedCount = reader.positiveSafeInt64("SHAPES compressed count", MAX_SHAPE_SAMPLES);
+      reader.requireArray(packedCount, 4, "SHAPES compressed data");
+      const packed = new Float64Array(packedCount);
+      for (let j = 0; j < packedCount; j++) packed[j] = reader.float32("SHAPES sample");
+      seq.shapes.set(id, { numSamples, samples: decompressShape(packed, numSamples) });
+    }
+  }
+  function readExtensions(reader, seq) {
+    const count = reader.count64("EXTENSIONS count", 16);
+    seq.extensions.clear();
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("EXTENSIONS id");
+      seq.extensions.set(id, {
+        id,
+        type: reader.int32("EXTENSIONS type"),
+        ref: reader.int32("EXTENSIONS reference"),
+        nextId: reader.int32("EXTENSIONS next id")
+      });
+    }
+  }
+  function registerExtension(seq, id, name) {
+    seq.extensionNames.set(id, name);
+    seq.extensionTypes.set(id, extensionNameToType(name));
+  }
+  function readTriggers(reader, seq) {
+    const extensionId = reader.int32("TRIGGERS extension type id");
+    registerExtension(seq, extensionId, "TRIGGERS");
+    const count = reader.count64("TRIGGERS count", 28);
+    seq.triggers.length = 0;
+    for (let i = 0; i < count; i++) {
+      seq.triggers.push({
+        id: reader.int32("TRIGGERS id"),
+        triggerType: reader.int32("TRIGGERS type"),
+        channel: reader.int32("TRIGGERS channel"),
+        delay: psToUsRounded(reader.safeInt64("TRIGGERS delay")),
+        duration: psToUsRounded(reader.safeInt64("TRIGGERS duration"))
+      });
+    }
+  }
+  function readLabels(reader, seq, isSet) {
+    const section = isSet ? "LABELSET" : "LABELINC";
+    const extensionId = reader.int32(`${section} extension type id`);
+    registerExtension(seq, extensionId, section);
+    const count = reader.count64(`${section} count`, 12);
+    const library = isSet ? seq.labelSets : seq.labelIncs;
+    library.length = 0;
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32(`${section} id`);
+      const value = reader.int32(`${section} value`);
+      const labelIndex = reader.int32(`${section} label index`);
+      if (labelIndex < 1 || labelIndex > BINARY_LABELS.length) {
+        reader.fail(`invalid binary label index ${labelIndex}`);
+      }
+      const { labelId, flagId } = decodeLabel(BINARY_LABELS[labelIndex - 1]);
+      const spec = { id, value, labelId, flagId };
+      library.push(spec);
+    }
+  }
+  function readSoftDelays(reader, seq) {
+    const extensionId = reader.int32("DELAYS extension type id");
+    registerExtension(seq, extensionId, "DELAYS");
+    const count = reader.count64("DELAYS count", 28);
+    seq.softDelays.length = 0;
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("DELAYS id");
+      const numId = reader.int32("DELAYS numeric id");
+      const offset = psToUsRounded(reader.safeInt64("DELAYS offset"));
+      const factor = reader.float64("DELAYS factor");
+      const hintLength = reader.length32("DELAYS hint length");
+      seq.softDelays.push({ id, numId, offset, factor, hint: reader.string(hintLength, "DELAYS hint") });
+    }
+  }
+  function readRfShims(reader, seq) {
+    const extensionId = reader.int32("RF_SHIMS extension type id");
+    registerExtension(seq, extensionId, "RF_SHIMS");
+    const count = reader.count64("RF_SHIMS count", 8);
+    seq.rfShims.length = 0;
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("RF_SHIMS id");
+      const nChannels = reader.length32("RF_SHIMS channel count", MAX_RECORDS / 2);
+      reader.requireArray(nChannels * 2, 8, "RF_SHIMS channel data");
+      const amplitudes = new Array(nChannels);
+      const phases = new Array(nChannels);
+      for (let channel = 0; channel < nChannels; channel++) {
+        amplitudes[channel] = reader.float64("RF_SHIMS magnitude");
+        phases[channel] = reader.float64("RF_SHIMS phase");
       }
+      seq.rfShims.push({ id, nChannels, amplitudes, phases });
+    }
+  }
+  function readRotations(reader, seq) {
+    const extensionId = reader.int32("ROTATIONS extension type id");
+    registerExtension(seq, extensionId, "ROTATIONS");
+    const count = reader.count64("ROTATIONS count", 36);
+    seq.rotations.length = 0;
+    for (let i = 0; i < count; i++) {
+      const id = reader.int32("ROTATIONS id");
+      const values = [
+        reader.float64("ROTATIONS q0"),
+        reader.float64("ROTATIONS qx"),
+        reader.float64("ROTATIONS qy"),
+        reader.float64("ROTATIONS qz")
+      ];
+      const norm = Math.hypot(...values);
+      if (!Number.isFinite(norm) || norm <= 0) reader.fail("invalid zero or non-finite rotation quaternion");
+      seq.rotations.push({ id, values: values.map((value) => value / norm) });
     }
-    if (!seenSections.has("BLOCKS")) parseError("Required [BLOCKS] section is missing");
-    for (const block of seq.blocks) {
-      if (block.rfId > 0 && !seq.rfs.has(block.rfId)) {
-        parseError(`Block ${block.num} references undefined RF event ${block.rfId}`);
+  }
+  function readSignature(reader, seq, sectionOffset) {
+    const typeLength = reader.length32("SIGNATURE type length");
+    const type = reader.string(typeLength, "SIGNATURE type");
+    const hashLength = reader.length32("SIGNATURE hash length");
+    const hashBytes = reader.bytes(hashLength, "SIGNATURE hash");
+    const originalSize = reader.nonNegativeSafeInt64("SIGNATURE original size");
+    if (originalSize !== sectionOffset) {
+      reader.fail(`SIGNATURE original size ${originalSize} does not match section offset ${sectionOffset}`);
+    }
+    let hash = "";
+    for (const byte of hashBytes) hash += byte.toString(16).padStart(2, "0");
+    seq.binarySignature = { type, hash, originalSize };
+  }
+  function psToUs(value) {
+    return value / 1e6;
+  }
+  function psToUsRounded(value) {
+    return value >= 0 ? Math.floor((value + 5e5) / 1e6) : Math.ceil((value - 5e5) / 1e6);
+  }
+  function psToNsRounded(value) {
+    return value >= 0 ? Math.floor((value + 500) / 1e3) : Math.ceil((value - 500) / 1e3);
+  }
+  var BinaryReader = class {
+    constructor(source) {
+      __publicField(this, "source", source);
+      __publicField(this, "view");
+      __publicField(this, "offset", 0);
+      this.view = new DataView(source.buffer, source.byteOffset, source.byteLength);
+    }
+    get position() {
+      return this.offset;
+    }
+    get remaining() {
+      return this.view.byteLength - this.offset;
+    }
+    eof() {
+      return this.remaining === 0;
+    }
+    requireArray(count, width, context) {
+      if (!Number.isSafeInteger(count) || count < 0 || count > MAX_RECORDS) {
+        this.fail(`${context} has invalid count ${count}`);
       }
-      for (const [channel, gradId] of [["GX", block.gxId], ["GY", block.gyId], ["GZ", block.gzId]]) {
-        if (gradId > 0 && !seq.arbitraryGrads.has(gradId) && !seq.trapGrads.has(gradId)) {
-          parseError(`Block ${block.num} references undefined ${channel} gradient event ${gradId}`);
-        }
+      if (count > Math.floor(this.remaining / width)) {
+        this.fail(`${context} exceeds remaining file data`);
       }
-      if (block.adcId > 0 && !seq.adcs.has(block.adcId)) {
-        parseError(`Block ${block.num} references undefined ADC event ${block.adcId}`);
+    }
+    count64(context, minimumBytesPerEntry) {
+      const count = this.nonNegativeSafeInt64(context);
+      if (count > MAX_RECORDS) this.fail(`${context} exceeds limit ${MAX_RECORDS}`);
+      if (minimumBytesPerEntry > 0 && count > Math.floor(this.remaining / minimumBytesPerEntry)) {
+        this.fail(`${context} exceeds remaining file data`);
       }
-      if (block.extId > 0 && !seq.extensions.has(block.extId)) {
-        parseError(`Block ${block.num} references undefined extension list ${block.extId}`);
+      return count;
+    }
+    length32(context, limit = MAX_STRING_BYTES) {
+      const value = this.int32(context);
+      if (value < 0 || value > limit) this.fail(`${context} has invalid value ${value}`);
+      if (value > this.remaining) this.fail(`${context} exceeds remaining file data`);
+      return value;
+    }
+    positiveSafeInt64(context, limit) {
+      const value = this.safeInt64(context);
+      if (value <= 0 || value > limit) this.fail(`${context} has invalid value ${value}`);
+      return value;
+    }
+    nonNegativeSafeInt64(context) {
+      const value = this.safeInt64(context);
+      if (value < 0) this.fail(`${context} must be non-negative`);
+      return value;
+    }
+    safeInt64(context) {
+      const value = this.int64(context);
+      if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
+        this.fail(`${context} exceeds JavaScript safe integer range`);
       }
+      return Number(value);
+    }
+    int64(context) {
+      this.require(8, context);
+      const value = this.view.getBigInt64(this.offset, true);
+      this.offset += 8;
+      return value;
+    }
+    uint64(context) {
+      this.require(8, context);
+      const value = this.view.getBigUint64(this.offset, true);
+      this.offset += 8;
+      return value;
+    }
+    int32(context) {
+      this.require(4, context);
+      const value = this.view.getInt32(this.offset, true);
+      this.offset += 4;
+      return value;
+    }
+    float64(context) {
+      this.require(8, context);
+      const value = this.view.getFloat64(this.offset, true);
+      this.offset += 8;
+      if (!Number.isFinite(value)) this.fail(`${context} is not finite`, this.offset - 8);
+      return value;
+    }
+    float32(context) {
+      this.require(4, context);
+      const value = this.view.getFloat32(this.offset, true);
+      this.offset += 4;
+      if (!Number.isFinite(value)) this.fail(`${context} is not finite`, this.offset - 4);
+      return value;
+    }
+    char(context) {
+      return this.string(1, context);
+    }
+    string(length, context) {
+      const data = this.bytes(length, context);
+      let result = "";
+      const chunkSize = 8192;
+      for (let start = 0; start < data.length; start += chunkSize) {
+        const end = Math.min(data.length, start + chunkSize);
+        result += String.fromCharCode(...data.subarray(start, end));
+      }
+      return result;
     }
-    for (const ext of seq.extensions.values()) {
-      if (ext.nextId > 0 && !seq.extensions.has(ext.nextId)) {
-        parseError(`Extension list ${ext.id} references undefined next extension ${ext.nextId}`);
+    bytes(length, context) {
+      if (!Number.isSafeInteger(length) || length < 0 || length > MAX_STRING_BYTES) {
+        this.fail(`${context} has invalid byte length ${length}`);
       }
-      const type = seq.extensionTypes.get(ext.type) ?? 999 /* EXT_UNKNOWN */;
-      if (type === 999 /* EXT_UNKNOWN */) continue;
-      if (!extensionPayloadExists(seq, type, ext.ref)) {
-        const name = seq.extensionNames.get(ext.type) ?? `type ${ext.type}`;
-        parseError(`Extension list ${ext.id} references undefined ${name} payload ${ext.ref}`);
+      this.require(length, context);
+      const result = this.source.subarray(this.offset, this.offset + length);
+      this.offset += length;
+      return result;
+    }
+    fail(message, offset = this.offset) {
+      throw new Error(`Pulseq binary parse error at byte ${offset}: ${message}`);
+    }
+    require(length, context) {
+      if (length < 0 || length > this.remaining) {
+        this.fail(`unexpected end of file while reading ${context}`);
       }
     }
-  }
-  function requireNumericDefinition(seq, name) {
-    const value = seq.definitions.get(name);
-    if (!value || value.length === 0 || !Number.isFinite(value[0])) {
-      parseError(`Required definition ${name} is not present in the file`);
+  };
+  // src/pulseq/sequenceReader.ts
+  function parseSequenceBytes(bytes, fileName = "") {
+    if (hasPulseqBinaryMagic(bytes)) return parseSequenceBinary(bytes);
+    if (/\.bseq$/i.test(fileName)) {
+      throw new Error("Pulseq binary parse error: .bseq file is missing the Pulseq binary header");
     }
-  }
-  function extensionPayloadExists(seq, type, ref) {
-    switch (type) {
-      case 1 /* EXT_TRIGGER */:
-        return seq.triggers.some((v) => v.id === ref);
-      case 2 /* EXT_ROTATION */:
-        return seq.rotations.some((v) => v.id === ref);
-      case 3 /* EXT_LABELSET */:
-        return seq.labelSets.some((v) => v.id === ref);
-      case 4 /* EXT_LABELINC */:
-        return seq.labelIncs.some((v) => v.id === ref);
-      case 5 /* EXT_DELAY */:
-        return seq.softDelays.some((v) => v.id === ref);
-      case 6 /* EXT_RF_SHIM */:
-        return seq.rfShims.some((v) => v.id === ref);
-      case 100 /* EXT_NCO */:
-        return seq.ncos.some((v) => v.id === ref);
-      default:
-        return false;
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      throw new Error("Pulseq parse error: sequence text is not valid UTF-8");
     }
+    return parseSequenceText(text);
   }
   // src/pulseq/decoder.ts
@@ -2182,6 +2750,13 @@ var Pulseq = (() => {
   // src/pulseq/kspaceExportArtifacts.ts
   function exportKspaceArtifacts(sequenceText, sequenceName, options = {}) {
     const seq = parseSequenceText(sequenceText);
+    return exportKspaceArtifactsFromSequence(seq, sequenceName, options);
+  }
+  function exportKspaceArtifactsFromBytes(sequenceBytes, sequenceName, options = {}) {
+    const seq = parseSequenceBytes(sequenceBytes, sequenceName);
+    return exportKspaceArtifactsFromSequence(seq, sequenceName, options);
+  }
+  function exportKspaceArtifactsFromSequence(seq, sequenceName, options = {}) {
     const decoded = decodeAllBlocks(seq);
     const totalDuration = getTotalDuration(seq);
     const gradientSupport = options.gradientSupport ?? "all";

seqeyes/resources/viewer.html CHANGED Viewed

@@ -73,7 +73,7 @@ body.layout-vertical #rc{flex-direction:row;gap:4px;top:6px;left:4px}
 <body>
 <!-- ── Toolbar ── -->
 <div id="tb">
-<button id="openBtn" title="Open another .seq file">📂 Open</button>
+<button id="openBtn" title="Open another .seq or .bseq file">📂 Open</button>
 <button id="zi" title="Zoom In (scroll wheel)">+</button>
 <button id="zo" title="Zoom Out">−</button>
 <button id="zf" title="Fit All">Fit</button>
@@ -107,7 +107,7 @@ body.layout-vertical #rc{flex-direction:row;gap:4px;top:6px;left:4px}
 <div id="right"><div class="handle" id="khandle"></div><canvas id="kg"></canvas><canvas id="kc"></canvas><div id="rc"><button id="krst" title="Reset view">↺</button><button id="kax" title="Toggle projection">Prj</button><button id="kunit" title="Toggle k-space unit (1/m ↔ rad/m)">Unit: 1/m</button><div style="display:flex;align-items:center;gap:2px;margin-top:4px"><span style="font-size:9px;color:var(--lb)">Size</span><input type="range" id="kdot" min="1" max="12" value="2" style="width:50px;accent-color:var(--adc)" title="ADC marker size"></div></div></div>
 </div>
 <!-- Hidden file inputs for standalone mode -->
-<input type="file" id="fileInput" accept=".seq" style="display:none">
+<input type="file" id="fileInput" accept=".seq,.bseq" style="display:none">
 <input type="file" id="ascFileInput" accept=".asc" style="display:none">
 <!-- ═══════════════════════════════════════════════════════════════════════
@@ -1239,8 +1239,8 @@ document.getElementById('theme').onchange=function(){
 document.getElementById('fileInput').onchange=function(){
   var file=this.files[0];if(!file)return;
   var reader=new FileReader();
-  reader.onload=function(){loadSequenceText(reader.result);};
-  reader.readAsText(file);
+  reader.onload=function(){loadSequenceBytes(new Uint8Array(reader.result),file.name);};
+  reader.readAsArrayBuffer(file);
 };
 // ── Minimap ──
@@ -1322,7 +1322,7 @@ new MutationObserver(function(){mmCache=null;draw();drawKs();drawMinimap();}).ob
    ═══════════════════════════════════════════════════════════════════════ */
 /**
- * Load raw .seq text, parse it, decode blocks, compute k‑space, and render.
+ * Load a parsed .seq/.bseq source, decode blocks, compute k-space, and render.
  * Called either:
  *   - automatically on page load if window.SEQEYES_RAW_B64 is set
  *   - when the user opens a file via the 📂 button
@@ -1396,10 +1396,10 @@ function convertBlock(blk) {
   return b;
 }
-function loadSequenceText(rawText) {
-  if (!rawText || typeof rawText !== 'string') return;
-  if (typeof Pulseq === 'undefined' || typeof Pulseq.parseSequenceText !== 'function') {
-    console.error('[SeqEyes] Pulseq bundle not loaded — cannot parse .seq text.');
+function loadSequence(parseSource) {
+  if (typeof parseSource !== 'function') return;
+  if (typeof Pulseq === 'undefined') {
+    console.error('[SeqEyes] Pulseq bundle not loaded — cannot parse sequence data.');
     return;
   }
@@ -1419,7 +1419,7 @@ function loadSequenceText(rawText) {
       fill.style.width = '20%'; pct.textContent = '20%';
       // Parse
-      var seq = Pulseq.parseSequenceText(rawText);
+      var seq = parseSource();
       fill.style.width = '40%'; pct.textContent = '40%';
       // Detect timing
@@ -1551,14 +1551,40 @@ function loadSequenceText(rawText) {
   });
 }
+function loadSequenceText(rawText) {
+  if (!rawText || typeof rawText !== 'string') return;
+  if (typeof Pulseq === 'undefined' || typeof Pulseq.parseSequenceText !== 'function') {
+    console.error('[SeqEyes] Pulseq bundle not loaded — cannot parse .seq text.');
+    return;
+  }
+  loadSequence(function() { return Pulseq.parseSequenceText(rawText); });
+}
+function loadSequenceBytes(rawBytes, fileName) {
+  if (!(rawBytes instanceof Uint8Array) || rawBytes.length === 0) return;
+  if (typeof Pulseq === 'undefined' || typeof Pulseq.parseSequenceBytes !== 'function') {
+    console.error('[SeqEyes] Pulseq bundle not loaded — cannot parse sequence bytes.');
+    return;
+  }
+  loadSequence(function() { return Pulseq.parseSequenceBytes(rawBytes, fileName || ''); });
+}
 /* SEQEYES_DATA_PLACEHOLDER */
 // ── Auto‑load on page start ──
 // Check for data injected by the Python host via base64
 if (window.SEQEYES_RAW_B64) {
   try {
-    var rawText = atob(window.SEQEYES_RAW_B64);
-    loadSequenceText(rawText);
+    var encodedSource = atob(window.SEQEYES_RAW_B64);
+    var sourceBytes = new Uint8Array(encodedSource.length);
+    for (var sourceIndex = 0; sourceIndex < encodedSource.length; sourceIndex++) {
+      sourceBytes[sourceIndex] = encodedSource.charCodeAt(sourceIndex);
+    }
+    if (window.SEQEYES_SOURCE_KIND === 'bytes') {
+      loadSequenceBytes(sourceBytes, window.SEQEYES_SOURCE_NAME || 'sequence.bseq');
+    } else {
+      loadSequenceText(new TextDecoder('utf-8').decode(sourceBytes));
+    }
   } catch(e) {
     console.error('[SeqEyes] Failed to decode base64 sequence data:', e);
   }
@@ -1569,10 +1595,10 @@ document.addEventListener('dragover', function(e) { e.preventDefault(); });
 document.addEventListener('drop', function(e) {
   e.preventDefault();
   var file = e.dataTransfer.files[0];
-  if (!file || !file.name.endsWith('.seq')) return;
+  if (!file || !/\.(?:seq|bseq)$/i.test(file.name)) return;
   var reader = new FileReader();
-  reader.onload = function() { loadSequenceText(reader.result); };
-  reader.readAsText(file);
+  reader.onload = function() { loadSequenceBytes(new Uint8Array(reader.result), file.name); };
+  reader.readAsArrayBuffer(file);
 });
 // ── Defer initial render until after browser layout is complete ──

{seqeyes_python-0.2.2.dist-info → seqeyes_python-0.2.6.dist-info}/METADATA RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqeyes-python
-Version: 0.2.2
+Version: 0.2.6
 Summary: Interactive Pulseq MRI sequence viewer for Jupyter — lightweight, beautiful, replaces seq.plot() in pypulseq.
 Project-URL: Homepage, https://github.com/bughht/seqeyes_plugin
 Project-URL: Repository, https://github.com/bughht/seqeyes_plugin
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 # SeqEyes — Interactive Pulseq MRI Sequence Viewer for Python
 **SeqEyes** is a lightweight Python package that provides interactive
-visualization of Pulseq (.seq) MRI sequences in Jupyter notebooks.
+visualization of Pulseq text (`.seq`) and binary (`.bseq`) MRI sequences in Jupyter notebooks.
 It works as a drop‑in replacement for `pypulseq.Sequence.plot()`,
 rendering an interactive viewer directly in Jupyter notebook cell
 output — just like Plotly.
@@ -90,13 +90,23 @@ with open('my_sequence.seq') as f:
 viewer  # renders inline in Jupyter
 ```
+Open either supported file format directly:
+```python
+from seqeyes import SeqEyesViewer
+SeqEyesViewer.from_file("my_sequence.seq", theme="dark")
+SeqEyesViewer.from_file("my_sequence.bseq", theme="dark")
+```
 ## API Reference
 | Function | Description |
 |---|---|
 | `seqeyes.set(**kwargs)` | Enable SeqEyes and set global defaults (`theme`, `show_blocks`, `time_disp`, `grad_disp`, `time_range`) |
 | `seqeyes.reset()` | Restore matplotlib `seq.plot()` and clear all defaults |
-| `SeqEyesViewer(seq_text, ...)` | Low‑level viewer for raw `.seq` content (no pypulseq needed) |
+| `SeqEyesViewer(source, ...)` | Low-level viewer for raw `.seq` text or `.bseq` bytes |
+| `SeqEyesViewer.from_file(path, ...)` | Open a local `.seq` or `.bseq` file without pypulseq |
 ## Viewer Controls

seqeyes_python-0.2.6.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,8 @@
+seqeyes/__init__.py,sha256=GpvQX637Z8yqYHz6arELQmXasuQm8dC-sJu6M1IP0Fs,944
+seqeyes/_plot.py,sha256=v5cPAn3mO017lQlNR4bthC0QgIBK1YxjygJTAPFUz1E,8114
+seqeyes/_renderer.py,sha256=vIB0lBeuOyK6p3MyQ0qeBy-JoEUVGISxtfdny7JoqKE,9862
+seqeyes/resources/pulseq-bundle.js,sha256=IJpZwkgi3-pftb3qVMuUNK1xMQwkVpbXecuj_jem2JE,104992
+seqeyes/resources/viewer.html,sha256=AovT33ptVfkP2iEaIBklRQGZV1tag_OBQardKtxpru8,88066
+seqeyes_python-0.2.6.dist-info/METADATA,sha256=9jH27I0J6qeaDP9gjHtvDdsjRHDifiwstn4GueZ-4Hw,4502
+seqeyes_python-0.2.6.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+seqeyes_python-0.2.6.dist-info/RECORD,,

seqeyes_python-0.2.2.dist-info/RECORD DELETED Viewed

@@ -1,8 +0,0 @@
-seqeyes/__init__.py,sha256=gLG6iHqBTpn2e8O8Xo-S4maZZO7yvGlbavEKMH86bQo,944
-seqeyes/_plot.py,sha256=v5cPAn3mO017lQlNR4bthC0QgIBK1YxjygJTAPFUz1E,8114
-seqeyes/_renderer.py,sha256=da7cK65iqRt9vMkrVE80d9VFL05a0BAzFvW7oXlbT_s,8441
-seqeyes/resources/pulseq-bundle.js,sha256=Np9sE0OWxgLHlZ43TOpzWzwuYUGmCtBluXwdxZs8XpA,83126
-seqeyes/resources/viewer.html,sha256=EUiBO49YWrrLu6cB6wA8SFA6EXG0WwGnbUk6CbkgLfs,86852
-seqeyes_python-0.2.2.dist-info/METADATA,sha256=MryZDrpaLUgWKvNLCIPRgX15jl1Pfu3VxZoTHFMdfcA,4179
-seqeyes_python-0.2.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-seqeyes_python-0.2.2.dist-info/RECORD,,

{seqeyes_python-0.2.2.dist-info → seqeyes_python-0.2.6.dist-info}/WHEEL RENAMED Viewed

File without changes

seqeyes-python 0.2.2__py3-none-any.whl → 0.2.6__py3-none-any.whl

seqeyes-python 0.2.2py3-none-any.whl → 0.2.6py3-none-any.whl