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

seqeyes/resources/pulseq-bundle.js

@@ -23,22 +23,37 @@ var Pulseq = (() => {
   // web/pulseq-browser.ts
   var pulseq_browser_exports = {};
   __export(pulseq_browser_exports, {
+    INTERACTIVE_COMPUTE_LIMITS: () => INTERACTIVE_COMPUTE_LIMITS,
     PACKAGE_VERSION: () => PACKAGE_VERSION,
     calculateKspace: () => calculateKspace,
     calculateM1: () => calculateM1,
+    calculateM1Coarse: () => calculateM1Coarse,
     calculatePns: () => calculatePns,
+    calculatePnsCoarse: () => calculatePnsCoarse,
     decodeAllBlocks: () => decodeAllBlocks,
     detectSequenceTiming: () => detectSequenceTiming,
+    estimateDerivedCost: () => estimateDerivedCost,
+    estimateKspaceCost: () => estimateKspaceCost,
+    estimateKspacePeakMemoryBytes: () => estimateKspacePeakMemoryBytes,
     exportKspaceArtifacts: () => exportKspaceArtifacts,
+    exportKspaceArtifactsFromBytes: () => exportKspaceArtifactsFromBytes,
+    exportKspaceArtifactsFromSequence: () => exportKspaceArtifactsFromSequence,
+    formatMemorySize: () => formatMemorySize,
+    formatSampleCount: () => formatSampleCount,
     formatTrajectoryText: () => formatTrajectoryText,
     getTotalDuration: () => getTotalDuration,
+    hasPulseqBinaryMagic: () => hasPulseqBinaryMagic,
     parsePnsHardwareAsc: () => parsePnsHardwareAsc,
+    parseSequenceBinary: () => parseSequenceBinary,
+    parseSequenceBytes: () => parseSequenceBytes,
     parseSequenceText: () => parseSequenceText,
-    safePnsModel: () => safePnsModel
+    safePnsModel: () => safePnsModel,
+    selectM1WindowBlocks: () => selectM1WindowBlocks,
+    selectPnsWindowBlocks: () => selectPnsWindowBlocks
   });
 
   // package.json
-  var version = "0.2.2";
+  var version = "0.2.7";
 
   // src/pulseq/decompressor.ts
   function decompressShape(compressed, numSamples) {
@@ -103,6 +118,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 +372,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 +619,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 +679,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 +734,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 +844,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 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
+      );
+    }
+  }
+  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}'`);
+      }
+    }
+  }
+  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) });
+    }
+  }
+  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 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 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);
     }
-    const vc = ver(seq);
-    if (vc >= VER_PRE_14) {
-      requireNumericDefinition(seq, "AdcRasterTime");
-      requireNumericDefinition(seq, "GradientRasterTime");
-      requireNumericDefinition(seq, "RadiofrequencyRasterTime");
-      requireNumericDefinition(seq, "BlockDurationRaster");
+    get position() {
+      return this.offset;
     }
-    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}'`);
-        }
-      }
+    get remaining() {
+      return this.view.byteLength - this.offset;
     }
-    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}`);
+    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
@@ -1216,6 +1794,11 @@ var Pulseq = (() => {
     for (const b of blocks) {
       if (b.adc) totalAdcSamples += b.adc.numSamples;
     }
+    if (_options?.maxAdcSamples && totalAdcSamples > _options.maxAdcSamples) return null;
+    if (_options?.maxGridPoints && totalDuration > 0) {
+      const rasterPointCount = Math.max(2, Math.round(totalDuration / GR) + 1);
+      if (rasterPointCount + totalAdcSamples > _options.maxGridPoints) return null;
+    }
     const adcT = new Float64Array(totalAdcSamples);
     let adcIdx = 0;
     for (const b of blocks) {
@@ -1447,8 +2030,140 @@ var Pulseq = (() => {
     return [gx, gy, gz];
   }
 
-  // src/pulseq/m1.ts
+  // src/pulseq/boundedSeries.ts
+  var BoundedSeriesBuilder = class {
+    constructor(startSec, endSec, maxPoints) {
+      __publicField(this, "startSec", startSec);
+      __publicField(this, "endSec", endSec);
+      __publicField(this, "buckets");
+      __publicField(this, "bucketCount");
+      __publicField(this, "span");
+      this.bucketCount = Math.max(1, Math.floor(Math.max(4, maxPoints) / 4));
+      this.buckets = new Array(this.bucketCount);
+      this.span = Math.max(0, endSec - startSec);
+    }
+    add(tSec, value) {
+      if (!Number.isFinite(tSec) || !Number.isFinite(value)) return;
+      const normalized = this.span > 0 ? (tSec - this.startSec) / this.span : 0;
+      const index = Math.max(0, Math.min(
+        this.bucketCount - 1,
+        Math.floor(normalized * this.bucketCount)
+      ));
+      const bucket = this.buckets[index];
+      if (!bucket) {
+        this.buckets[index] = {
+          firstT: tSec,
+          firstV: value,
+          minV: value,
+          maxV: value,
+          lastT: tSec,
+          lastV: value
+        };
+        return;
+      }
+      if (value < bucket.minV) {
+        bucket.minV = value;
+      }
+      if (value > bucket.maxV) {
+        bucket.maxV = value;
+      }
+      bucket.lastT = tSec;
+      bucket.lastV = value;
+    }
+    finish() {
+      const startTime = [];
+      const endTime = [];
+      const min = [];
+      const max = [];
+      const first = [];
+      const last = [];
+      for (const bucket of this.buckets) {
+        if (!bucket) continue;
+        startTime.push(bucket.firstT);
+        endTime.push(bucket.lastT);
+        min.push(bucket.minV);
+        max.push(bucket.maxV);
+        first.push(bucket.firstV);
+        last.push(bucket.lastV);
+      }
+      return {
+        startTime: new Float64Array(startTime),
+        endTime: new Float64Array(endTime),
+        min: new Float64Array(min),
+        max: new Float64Array(max),
+        first: new Float64Array(first),
+        last: new Float64Array(last)
+      };
+    }
+  };
+
+  // src/pulseq/gradientSampler.ts
   var TIME_EPS = 1e-15;
+  function decodedGradientTimeRange(blocks) {
+    let first = Number.POSITIVE_INFINITY;
+    let last = Number.NEGATIVE_INFINITY;
+    for (const block of blocks) {
+      for (const gradient of [block.gx, block.gy, block.gz]) {
+        if (!gradient?.timePoints.length) continue;
+        const gradientFirst = gradient.timePoints[0];
+        const gradientLast = gradient.timePoints[gradient.timePoints.length - 1];
+        if (Number.isFinite(gradientFirst)) first = Math.min(first, gradientFirst);
+        if (Number.isFinite(gradientLast)) last = Math.max(last, gradientLast);
+      }
+    }
+    return Number.isFinite(first) && Number.isFinite(last) && last >= first ? { first, last } : void 0;
+  }
+  function createDecodedGradientSampler(blocks, channel) {
+    const events = [];
+    for (const block of blocks) {
+      const gradient = block[channel];
+      if (!gradient?.timePoints.length || !gradient.waveform.length) continue;
+      const n = Math.min(gradient.timePoints.length, gradient.waveform.length);
+      if (n < 1) continue;
+      events.push({
+        gradient,
+        first: gradient.timePoints[0],
+        last: gradient.timePoints[n - 1]
+      });
+    }
+    events.sort((a, b) => a.first - b.first);
+    let eventIndex = 0;
+    let pointIndex = 0;
+    let previousTime = Number.NEGATIVE_INFINITY;
+    return (timeSec) => {
+      if (timeSec < previousTime - TIME_EPS) {
+        eventIndex = 0;
+        pointIndex = 0;
+      }
+      previousTime = timeSec;
+      while (eventIndex < events.length && events[eventIndex].last < timeSec - TIME_EPS) {
+        eventIndex++;
+        pointIndex = 0;
+      }
+      if (eventIndex >= events.length) return 0;
+      const event = events[eventIndex];
+      if (timeSec < event.first - TIME_EPS || timeSec > event.last + TIME_EPS) return 0;
+      const times = event.gradient.timePoints;
+      const values = event.gradient.waveform;
+      const n = Math.min(times.length, values.length);
+      if (Math.abs(timeSec - event.last) <= TIME_EPS && eventIndex + 1 < events.length) {
+        const next = events[eventIndex + 1];
+        if (Math.abs(next.first - timeSec) <= TIME_EPS && next.gradient.waveform.length) {
+          return 0.5 * (values[n - 1] + next.gradient.waveform[0]);
+        }
+      }
+      while (pointIndex + 1 < n && times[pointIndex + 1] <= timeSec + TIME_EPS) pointIndex++;
+      if (pointIndex >= n - 1 || timeSec <= times[pointIndex] + TIME_EPS) return values[pointIndex];
+      const t0 = times[pointIndex];
+      const t1 = times[pointIndex + 1];
+      if (!(t1 > t0)) return values[pointIndex];
+      const alpha = (timeSec - t0) / (t1 - t0);
+      return values[pointIndex] + alpha * (values[pointIndex + 1] - values[pointIndex]);
+    };
+  }
+
+  // src/pulseq/m1.ts
+  var TIME_EPS2 = 1e-15;
   function calculateM1(blocks, gradientRaster, options = {}) {
     const referenceMode = normalizeReferenceMode(options.referenceMode);
     if (!blocks.length) {
@@ -1471,10 +2186,38 @@ var Pulseq = (() => {
     const excitationTimes = rfEvents.filter((rf) => rf.use === "e").map((rf) => rf.tSec);
     const refocusingTimes = rfEvents.filter((rf) => rf.use === "r").map((rf) => rf.tSec);
     const events = buildWalkerEvents(rfEvents);
+    appendM1AdvisoryWarnings(rfEvents, tMin, warnings);
+    const rasterSec = gradientRaster > 0 ? gradientRaster : 1e-5;
+    if (rasterSec <= 0) {
+      return invalidM1("gradientRaster must be positive.", referenceMode);
+    }
+    const samples = buildSampleTimes(tMin, tMax, rasterSec);
+    const x = walkM1(gx, samples, events, excitationTimes, tMin, referenceMode);
+    const y = walkM1(gy, samples, events, excitationTimes, tMin, referenceMode);
+    const z = walkM1(gz, samples, events, excitationTimes, tMin, referenceMode);
+    if (x.t.length !== y.t.length || x.t.length !== z.t.length) {
+      warnings.push(`Internal warning: per-axis M1 output sizes disagree (${x.t.length}, ${y.t.length}, ${z.t.length}). Plot may be inconsistent.`);
+    }
+    return {
+      valid: true,
+      ok: true,
+      referenceMode,
+      tSec: new Float64Array(x.t),
+      m1x: new Float64Array(x.m1),
+      m1y: new Float64Array(y.m1),
+      m1z: new Float64Array(z.m1),
+      warnings,
+      excitationTimesSec: new Float64Array(excitationTimes),
+      refocusingTimesSec: new Float64Array(refocusingTimes)
+    };
+  }
+  function appendM1AdvisoryWarnings(rfEvents, tMin, warnings) {
     let recentExcCount = 0;
     let lastExcT = -1e9;
+    let excitationCount = 0;
     for (const rf of rfEvents) {
       if (rf.use === "e") {
+        excitationCount++;
         if (rf.tSec - lastExcT < 0.1) recentExcCount++;
         lastExcT = rf.tSec;
       }
@@ -1484,28 +2227,122 @@ var Pulseq = (() => {
         `Sequence shows ${recentExcCount} closely-spaced (<100 ms) excitation events. This pattern is consistent with a steady-state sequence for which the simplified reset/flip bookkeeping does NOT model coherent pathway interference. Treat the M1 curve as advisory only.`
       );
     }
-    if (!excitationTimes.length) {
+    if (!excitationCount) {
       warnings.push(`No excitation RF events found in sequence. M1 will be integrated from t=${tMin.toFixed(6)} s with no signal basis.`);
     }
-    const rasterSec = gradientRaster > 0 ? gradientRaster : 1e-5;
-    if (rasterSec <= 0) {
-      return invalidM1("gradientRaster must be positive.", referenceMode);
-    }
-    const samples = buildSampleTimes(tMin, tMax, rasterSec);
-    const x = walkM1(gx, samples, events, excitationTimes, tMin, referenceMode);
-    const y = walkM1(gy, samples, events, excitationTimes, tMin, referenceMode);
-    const z = walkM1(gz, samples, events, excitationTimes, tMin, referenceMode);
-    if (x.t.length !== y.t.length || x.t.length !== z.t.length) {
-      warnings.push(`Internal warning: per-axis M1 output sizes disagree (${x.t.length}, ${y.t.length}, ${z.t.length}). Plot may be inconsistent.`);
+  }
+  function calculateM1Coarse(blocks, gradientRaster, options = {}) {
+    const referenceMode = normalizeReferenceMode(options.referenceMode);
+    const emptySeries = () => ({
+      startTime: new Float64Array(),
+      endTime: new Float64Array(),
+      min: new Float64Array(),
+      max: new Float64Array(),
+      first: new Float64Array(),
+      last: new Float64Array()
+    });
+    const invalid = (error) => ({
+      valid: false,
+      ok: false,
+      coarse: true,
+      referenceMode,
+      error,
+      startSec: 0,
+      endSec: 0,
+      x: emptySeries(),
+      y: emptySeries(),
+      z: emptySeries(),
+      warnings: [],
+      excitationTimesSec: new Float64Array(),
+      refocusingTimesSec: new Float64Array()
+    });
+    if (!blocks.length) return invalid("Empty or invalid block list.");
+    if (!(gradientRaster > 0)) return invalid("gradientRaster must be positive.");
+    const range = decodedGradientTimeRange(blocks);
+    if (!range) return invalid("No gradient waveform available for M1.");
+    const warnings = [];
+    const rfEvents = collectRfEvents(blocks, warnings);
+    appendM1AdvisoryWarnings(rfEvents, range.first, warnings);
+    const excitationTimes = rfEvents.filter((rf) => rf.use === "e").map((rf) => rf.tSec);
+    const refocusingTimes = rfEvents.filter((rf) => rf.use === "r").map((rf) => rf.tSec);
+    const events = buildWalkerEvents(rfEvents);
+    const startSec = Math.min(range.first, events[0]?.tSec ?? range.first);
+    const endSec = Math.max(range.last, events[events.length - 1]?.tSec ?? range.last);
+    const maxPoints = Math.max(1024, Math.min(12e4, options.maxPoints ?? 3e4));
+    const maxBuckets = Math.floor(maxPoints / 4);
+    const builders = [
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints),
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints),
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints)
+    ];
+    const samplers = [
+      createDecodedGradientSampler(blocks, "gx"),
+      createDecodedGradientSampler(blocks, "gy"),
+      createDecodedGradientSampler(blocks, "gz")
+    ];
+    const unsignedM0 = [0, 0, 0];
+    const unsignedM1 = [0, 0, 0];
+    let sign = 1;
+    let tReset = excitationTimes.length ? excitationTimes[0] : range.first;
+    if (range.first < tReset) tReset = range.first;
+    let currentT = tReset;
+    const reported = (axis, tSec) => referenceMode === "observationTime" ? sign * (unsignedM1[axis] - (tSec - tReset) * unsignedM0[axis]) : sign * unsignedM1[axis];
+    const advanceTo = (targetT) => {
+      if (!(targetT > currentT + TIME_EPS2)) return;
+      for (let axis = 0; axis < 3; axis++) {
+        const ga = samplers[axis](currentT);
+        const gb = samplers[axis](targetT);
+        const integrated = integrateLinearSegment(currentT, targetT, tReset, ga, gb);
+        unsignedM0[axis] += integrated[0];
+        unsignedM1[axis] += integrated[1];
+      }
+      currentT = targetT;
+    };
+    const addReported = (tSec) => {
+      for (let axis = 0; axis < 3; axis++) builders[axis].add(tSec, reported(axis, tSec));
+    };
+    const regularCount = Math.floor((range.last - range.first) / gradientRaster) + 1;
+    const regularLast = range.first + Math.max(0, regularCount - 1) * gradientRaster;
+    const hasFinalSample = regularLast < range.last - TIME_EPS2;
+    const totalSamples = regularCount + (hasFinalSample ? 1 : 0);
+    let eventIndex = 0;
+    let sampleIndex = 0;
+    while (eventIndex < events.length || sampleIndex < totalSamples) {
+      const eventTime = eventIndex < events.length ? events[eventIndex].tSec : Number.POSITIVE_INFINITY;
+      const sampleTime = sampleIndex < totalSamples ? sampleIndex < regularCount ? range.first + sampleIndex * gradientRaster : range.last : Number.POSITIVE_INFINITY;
+      if (eventTime <= sampleTime) {
+        advanceTo(eventTime);
+        if (events[eventIndex].kind === "reset") {
+          sign = 1;
+          tReset = eventTime;
+          currentT = eventTime;
+          unsignedM0.fill(0);
+          unsignedM1.fill(0);
+          for (const builder of builders) builder.add(eventTime, 0);
+        } else {
+          addReported(eventTime);
+          sign = -sign;
+        }
+        eventIndex++;
+      } else {
+        advanceTo(sampleTime);
+        addReported(sampleTime);
+        sampleIndex++;
+      }
     }
+    warnings.push(
+      `Showing a bounded full-sequence M1 envelope (at most ${maxBuckets.toLocaleString()} buckets per axis). Zoom to 100 TRs or fewer for an automatic detailed calculation.`
+    );
     return {
       valid: true,
       ok: true,
+      coarse: true,
       referenceMode,
-      tSec: new Float64Array(x.t),
-      m1x: new Float64Array(x.m1),
-      m1y: new Float64Array(y.m1),
-      m1z: new Float64Array(z.m1),
+      startSec,
+      endSec,
+      x: builders[0].finish(),
+      y: builders[1].finish(),
+      z: builders[2].finish(),
       warnings,
       excitationTimesSec: new Float64Array(excitationTimes),
       refocusingTimesSec: new Float64Array(refocusingTimes)
@@ -1544,7 +2381,7 @@ var Pulseq = (() => {
   function appendGradientPoint(series, t, value) {
     if (!Number.isFinite(t) || !Number.isFinite(value)) return;
     const last = series.time.length - 1;
-    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS) {
+    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS2) {
       series.value[last] = 0.5 * (series.value[last] + value);
     } else if (last < 0 || t > series.time[last]) {
       series.time.push(t);
@@ -1594,7 +2431,7 @@ var Pulseq = (() => {
     const samples = [];
     const nSamples = Math.floor((tMax - tMin) / rasterSec) + 1;
     for (let i = 0; i < nSamples; i++) samples.push(tMin + i * rasterSec);
-    if (!samples.length || samples[samples.length - 1] < tMax - TIME_EPS) samples.push(tMax);
+    if (!samples.length || samples[samples.length - 1] < tMax - TIME_EPS2) samples.push(tMax);
     return samples;
   }
   function walkM1(gradient, samples, events, excitationTimes, tMin, referenceMode) {
@@ -1608,16 +2445,16 @@ var Pulseq = (() => {
     let unsignedM1 = 0;
     let gradientIndex = -1;
     const seekGradient = (t) => {
-      while (gradientIndex + 1 < gradient.time.length && gradient.time[gradientIndex + 1] <= t + TIME_EPS) {
+      while (gradientIndex + 1 < gradient.time.length && gradient.time[gradientIndex + 1] <= t + TIME_EPS2) {
         gradientIndex++;
       }
     };
     const sampleGradient = (t) => {
       const n = gradient.time.length;
-      if (n === 0 || t < gradient.time[0] - TIME_EPS || t > gradient.time[n - 1] + TIME_EPS) return 0;
+      if (n === 0 || t < gradient.time[0] - TIME_EPS2 || t > gradient.time[n - 1] + TIME_EPS2) return 0;
       seekGradient(t);
       if (gradientIndex < 0) return 0;
-      if (gradientIndex >= n - 1 || Math.abs(t - gradient.time[gradientIndex]) <= TIME_EPS) {
+      if (gradientIndex >= n - 1 || Math.abs(t - gradient.time[gradientIndex]) <= TIME_EPS2) {
         return gradient.value[gradientIndex];
       }
       const t0 = gradient.time[gradientIndex];
@@ -1631,8 +2468,8 @@ var Pulseq = (() => {
       return sign * unsignedM1;
     };
     const advanceTo = (targetT) => {
-      if (!(targetT > currentT + TIME_EPS)) return;
-      while (currentT < targetT - TIME_EPS) {
+      if (!(targetT > currentT + TIME_EPS2)) return;
+      while (currentT < targetT - TIME_EPS2) {
         seekGradient(currentT);
         let nextT = gradientIndex + 1 < gradient.time.length ? Math.min(targetT, gradient.time[gradientIndex + 1]) : targetT;
         if (!(nextT > currentT)) nextT = targetT;
@@ -1652,7 +2489,7 @@ var Pulseq = (() => {
       if (nextEvtT <= nextSampT) {
         advanceTo(nextEvtT);
         if (events[ei].kind === "reset") {
-          if (!outT.length || outT[outT.length - 1] < nextEvtT - TIME_EPS) {
+          if (!outT.length || outT[outT.length - 1] < nextEvtT - TIME_EPS2) {
             outT.push(nextEvtT);
             outM1.push(0);
           } else {
@@ -1691,7 +2528,7 @@ var Pulseq = (() => {
 
   // src/pulseq/pns.ts
   var GAMMA_HZ_PER_T = 42576e3;
-  var TIME_EPS2 = 1e-15;
+  var TIME_EPS3 = 1e-15;
   function parsePnsHardwareAsc(text) {
     const asc = parseAscText(text);
     const prefix = resolvePnsPrefix(asc);
@@ -1823,6 +2660,148 @@ var Pulseq = (() => {
     }
     return { valid: true, ok, timeSec, pnsX, pnsY, pnsZ, pnsNorm };
   }
+  function calculatePnsCoarse(blocks, gradientRaster, hardware, options = {}) {
+    const emptySeries = () => ({
+      startTime: new Float64Array(),
+      endTime: new Float64Array(),
+      min: new Float64Array(),
+      max: new Float64Array(),
+      first: new Float64Array(),
+      last: new Float64Array()
+    });
+    const invalid = (error) => ({
+      valid: false,
+      ok: false,
+      coarse: true,
+      error,
+      startSec: 0,
+      endSec: 0,
+      x: emptySeries(),
+      y: emptySeries(),
+      z: emptySeries(),
+      norm: emptySeries(),
+      warnings: []
+    });
+    const gammaHzPerT = options.gammaHzPerT ?? GAMMA_HZ_PER_T;
+    if (!hardware.valid) return invalid("PNS hardware is not initialized.");
+    if (!blocks.length) return invalid("No sequence loaded.");
+    if (!(gradientRaster > 0) || !(gammaHzPerT > 0)) return invalid("Missing GradientRasterTime or gamma.");
+    const range = decodedGradientTimeRange(blocks);
+    if (!range || !(range.last > range.first)) return invalid("No gradient waveform available for PNS.");
+    const dtSec = gradientRaster;
+    let ntMin = Math.floor(range.first / dtSec + Number.EPSILON) + 0.5;
+    const ntMax = Math.ceil(range.last / dtSec - Number.EPSILON) - 0.5;
+    if (ntMin < 0.5) ntMin = 0.5;
+    if (ntMax < ntMin) return invalid("Unable to build regular PNS raster.");
+    const nSamples = Math.floor(ntMax - ntMin + 1);
+    if (nSamples < 2) return invalid("Too few samples for PNS computation.");
+    const longestTauMs = Math.max(
+      hardware.x.tau1Ms,
+      hardware.x.tau2Ms,
+      hardware.x.tau3Ms,
+      hardware.y.tau1Ms,
+      hardware.y.tau2Ms,
+      hardware.y.tau3Ms,
+      hardware.z.tau1Ms,
+      hardware.z.tau2Ms,
+      hardware.z.tau3Ms
+    );
+    const zptSec = longestTauMs * 4 / 1e3;
+    const preCount = Math.max(0, Math.round(zptSec / (4 * dtSec)));
+    const postCount = Math.max(0, Math.round(zptSec / dtSec));
+    const totalSamples = preCount + nSamples + postCount;
+    const hasAnyNonTrap = blocks.some((block) => block.gx?.type === "arb" || block.gy?.type === "arb" || block.gz?.type === "arb");
+    const hasAnyLabelExt = blocks.some((block) => !!(block.labelSets?.length || block.labelIncs?.length));
+    const shift = hasAnyNonTrap || hasAnyLabelExt ? 1 : 0;
+    const stimLength = Math.max(0, totalSamples - 1);
+    const desiredStimIndex = (origIndex) => {
+      const paddedIndex = preCount + origIndex;
+      if (shift > 0 && hasAnyLabelExt && origIndex === nSamples - 1) {
+        return Math.min(paddedIndex, stimLength - 1);
+      }
+      return paddedIndex - shift;
+    };
+    const startSec = ntMin * dtSec;
+    const endSec = (ntMin + nSamples - 1) * dtSec;
+    const maxPoints = Math.max(1024, Math.min(12e4, options.maxPoints ?? 3e4));
+    const maxBuckets = Math.floor(maxPoints / 4);
+    const builders = [
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints),
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints),
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints),
+      new BoundedSeriesBuilder(startSec, endSec, maxPoints)
+    ];
+    const samplers = [
+      createDecodedGradientSampler(blocks, "gx"),
+      createDecodedGradientSampler(blocks, "gy"),
+      createDecodedGradientSampler(blocks, "gz")
+    ];
+    const hardwareAxes = [hardware.x, hardware.y, hardware.z];
+    const filterStates = hardwareAxes.map((axis) => createPnsFilterState(axis, dtSec));
+    const paddedValue = (axis, index) => {
+      if (index < preCount || index >= preCount + nSamples) return 0;
+      const rasterIndex = index - preCount;
+      return samplers[axis]((ntMin + rasterIndex) * dtSec) / gammaHzPerT;
+    };
+    const previous = [paddedValue(0, 0), paddedValue(1, 0), paddedValue(2, 0)];
+    let outputIndex = 0;
+    let ok = true;
+    for (let stimIndex = 0; stimIndex < stimLength; stimIndex++) {
+      const normalized = [0, 0, 0];
+      for (let axis = 0; axis < 3; axis++) {
+        const current = paddedValue(axis, stimIndex + 1);
+        const derivative = (current - previous[axis]) / dtSec;
+        previous[axis] = current;
+        normalized[axis] = updatePnsFilter(filterStates[axis], derivative);
+      }
+      while (outputIndex < nSamples && desiredStimIndex(outputIndex) < stimIndex) outputIndex++;
+      if (outputIndex < nSamples && desiredStimIndex(outputIndex) === stimIndex) {
+        const timeSec = (ntMin + outputIndex) * dtSec;
+        const norm = Math.hypot(normalized[0], normalized[1], normalized[2]);
+        builders[0].add(timeSec, normalized[0]);
+        builders[1].add(timeSec, normalized[1]);
+        builders[2].add(timeSec, normalized[2]);
+        builders[3].add(timeSec, norm);
+        if (norm >= 1) ok = false;
+        outputIndex++;
+      }
+    }
+    const warnings = [
+      `Showing a bounded full-sequence PNS envelope (at most ${maxBuckets.toLocaleString()} buckets per curve). Zoom to 100 TRs or fewer for an automatic detailed calculation.`
+    ];
+    return {
+      valid: true,
+      ok,
+      coarse: true,
+      startSec,
+      endSec,
+      x: builders[0].finish(),
+      y: builders[1].finish(),
+      z: builders[2].finish(),
+      norm: builders[3].finish(),
+      warnings
+    };
+  }
+  function createPnsFilterState(hardware, dtSec) {
+    const dtMs = dtSec * 1e3;
+    return {
+      alpha1: lowpassAlpha(hardware.tau1Ms, dtMs),
+      alpha2: lowpassAlpha(hardware.tau2Ms, dtMs),
+      alpha3: lowpassAlpha(hardware.tau3Ms, dtMs),
+      lp1: 0,
+      lp2: 0,
+      lp3: 0,
+      hardware
+    };
+  }
+  function updatePnsFilter(state, derivative) {
+    state.lp1 = state.alpha1 * derivative + (1 - state.alpha1) * state.lp1;
+    state.lp2 = state.alpha2 * Math.abs(derivative) + (1 - state.alpha2) * state.lp2;
+    state.lp3 = state.alpha3 * derivative + (1 - state.alpha3) * state.lp3;
+    const hw = state.hardware;
+    const numerator = hw.a1 * Math.abs(state.lp1) + hw.a2 * state.lp2 + hw.a3 * Math.abs(state.lp3);
+    return numerator / (hw.stimLimit > 0 ? hw.stimLimit : 1) * hw.gScale;
+  }
   function safePnsModel(dgdt, dtSec, hw) {
     return runPnsModel(dgdt.length, (index) => dgdt[index], dtSec, hw);
   }
@@ -1961,7 +2940,7 @@ var Pulseq = (() => {
   function appendGradientPoint2(series, t, value) {
     if (!Number.isFinite(t) || !Number.isFinite(value)) return;
     const last = series.time.length - 1;
-    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS2) {
+    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS3) {
       series.value[last] = 0.5 * (series.value[last] + value);
     } else if (last < 0 || t > series.time[last]) {
       series.time.push(t);
@@ -1989,9 +2968,9 @@ var Pulseq = (() => {
     return (t) => {
       const n = series.time.length;
       if (n === 0 || t < series.time[0] || t > series.time[n - 1]) return 0;
-      while (index + 1 < n && series.time[index + 1] <= t + TIME_EPS2) index++;
+      while (index + 1 < n && series.time[index + 1] <= t + TIME_EPS3) index++;
       if (index < 0) return 0;
-      if (index >= n - 1 || t <= series.time[index] + TIME_EPS2) return series.value[index];
+      if (index >= n - 1 || t <= series.time[index] + TIME_EPS3) return series.value[index];
       const t0 = series.time[index];
       const t1 = series.time[index + 1];
       if (!(t1 > t0)) return series.value[index];
@@ -2000,6 +2979,135 @@ var Pulseq = (() => {
     };
   }
 
+  // src/pulseq/derivedWindow.ts
+  function selectM1WindowBlocks(blocks, startSec, endSec) {
+    const displayStartSec = finiteMin(startSec, endSec);
+    const displayEndSec = finiteMax(startSec, endSec, displayStartSec);
+    let calculationStartSec = displayStartSec;
+    for (const block of blocks) {
+      const center = block.rf?.centerTime;
+      if (center === void 0 || center > displayStartSec) continue;
+      const use = (block.rf?.use || "").toLowerCase();
+      if (use === "e") calculationStartSec = Math.min(center, block.startTime);
+    }
+    return {
+      blocks: overlappingBlocks(blocks, calculationStartSec, displayEndSec),
+      calculationStartSec,
+      displayStartSec,
+      displayEndSec
+    };
+  }
+  function selectPnsWindowBlocks(blocks, startSec, endSec, hardware) {
+    const displayStartSec = finiteMin(startSec, endSec);
+    const displayEndSec = finiteMax(startSec, endSec, displayStartSec);
+    const longestTauMs = Math.max(
+      hardware.x.tau1Ms,
+      hardware.x.tau2Ms,
+      hardware.x.tau3Ms,
+      hardware.y.tau1Ms,
+      hardware.y.tau2Ms,
+      hardware.y.tau3Ms,
+      hardware.z.tau1Ms,
+      hardware.z.tau2Ms,
+      hardware.z.tau3Ms
+    );
+    const calculationStartSec = Math.max(0, displayStartSec - longestTauMs * 4 / 1e3);
+    return {
+      blocks: overlappingBlocks(blocks, calculationStartSec, displayEndSec),
+      calculationStartSec,
+      displayStartSec,
+      displayEndSec
+    };
+  }
+  function overlappingBlocks(blocks, startSec, endSec) {
+    return blocks.filter((block) => block.startTime + block.duration > startSec && block.startTime <= endSec);
+  }
+  function finiteMin(a, b) {
+    const aa = Number.isFinite(a) ? a : 0;
+    const bb = Number.isFinite(b) ? b : aa;
+    return Math.max(0, Math.min(aa, bb));
+  }
+  function finiteMax(a, b, fallback) {
+    const aa = Number.isFinite(a) ? a : fallback;
+    const bb = Number.isFinite(b) ? b : aa;
+    return Math.max(fallback, Math.max(aa, bb));
+  }
+
+  // src/pulseq/computeBudget.ts
+  var INTERACTIVE_COMPUTE_LIMITS = Object.freeze({
+    kspaceRasterSamples: 12e6,
+    kspaceAdcSamples: 8e6,
+    kspaceGridCandidates: 18e6,
+    derivedRasterSamples: 2e6
+  });
+  function estimateKspaceCost(blocks, gradientRaster, totalDuration) {
+    let adcSamples = 0;
+    let gradientSupportPoints = 0;
+    let rfSupportPoints = 0;
+    for (const block of blocks) {
+      if (block.adc?.numSamples && block.adc.numSamples > 0) {
+        adcSamples += block.adc.numSamples;
+      }
+      for (const gradient of [block.gx, block.gy, block.gz]) {
+        if (gradient && gradient.type !== "none" && gradient.timePoints.length >= 2) {
+          gradientSupportPoints += 2;
+        }
+      }
+      if (block.rf) rfSupportPoints += block.rf.use === "r" ? 2 : 3;
+    }
+    const rasterSamples = gradientRaster > 0 && totalDuration > 0 ? Math.max(2, Math.round(totalDuration / gradientRaster) + 1) : 0;
+    const gridCandidatePoints = rasterSamples + adcSamples + gradientSupportPoints + rfSupportPoints + 2;
+    return { rasterSamples, adcSamples, gridCandidatePoints };
+  }
+  function estimateKspacePeakMemoryBytes(estimate) {
+    const gridBytes = Math.max(0, estimate.gridCandidatePoints) * 96;
+    const adcAndTransferBytes = Math.max(0, estimate.adcSamples) * 104;
+    return Math.ceil(Math.min(Number.MAX_SAFE_INTEGER, (gridBytes + adcAndTransferBytes) * 1.25));
+  }
+  function estimateDerivedCost(blocks, gradientRaster) {
+    let firstGradientTime = Infinity;
+    let lastGradientTime = -Infinity;
+    for (const block of blocks) {
+      for (const gradient of [block.gx, block.gy, block.gz]) {
+        const times = gradient?.timePoints;
+        if (!times?.length) continue;
+        const first = times[0];
+        const last = times[times.length - 1];
+        if (Number.isFinite(first) && first < firstGradientTime) firstGradientTime = first;
+        if (Number.isFinite(last) && last > lastGradientTime) lastGradientTime = last;
+      }
+    }
+    if (!Number.isFinite(firstGradientTime) || !Number.isFinite(lastGradientTime) || lastGradientTime < firstGradientTime || gradientRaster <= 0) {
+      return { rasterSamples: 0, firstGradientTime: null, lastGradientTime: null };
+    }
+    const span = lastGradientTime - firstGradientTime;
+    let rasterSamples = Math.max(1, Math.floor(span / gradientRaster) + 1);
+    const finalRasterTime = firstGradientTime + (rasterSamples - 1) * gradientRaster;
+    if (finalRasterTime < lastGradientTime - 1e-15) rasterSamples++;
+    return { rasterSamples, firstGradientTime, lastGradientTime };
+  }
+  function formatSampleCount(value) {
+    if (value >= 1e6) return `${(value / 1e6).toFixed(1)} million`;
+    if (value >= 1e3) return `${(value / 1e3).toFixed(1)} thousand`;
+    return String(value);
+  }
+  function formatMemorySize(bytes) {
+    const safeBytes = Math.max(0, Number.isFinite(bytes) ? bytes : 0);
+    const kib = 1024;
+    const mib = kib * 1024;
+    const gib = mib * 1024;
+    if (safeBytes >= gib) {
+      const value = safeBytes / gib;
+      return `${value.toFixed(value >= 10 ? 0 : 1)} GiB`;
+    }
+    if (safeBytes >= mib) {
+      const value = safeBytes / mib;
+      return `${value.toFixed(value >= 10 ? 0 : 1)} MiB`;
+    }
+    if (safeBytes >= kib) return `${(safeBytes / kib).toFixed(1)} KiB`;
+    return `${Math.round(safeBytes)} bytes`;
+  }
+
   // src/pulseq/trdetect.ts
   var GAMMA_HZ_T2 = 42576e3;
   var DEFAULT_B0_T2 = 3;
@@ -2182,6 +3290,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";