@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-UG5BTOTF.mjs

@@ -0,0 +1,334 @@
+import { ProgressiveFeed, decodeProgressive, decodeManifest, SegmentOp, segmentOutput, PartFormatError, applyDelta, decodePart, soleSpan, assembleInto } from './chunk-U6UVWEAK.mjs';
+import { chunkResolved, chunkNeeded } from './chunk-LYEZZEEF.mjs';
+import { ChunkPriority } from './chunk-V7ZRH3PY.mjs';
+
+// src/interactives/runtime/asset-parts.ts
+var AssetParts = class {
+  constructor() {
+    this.users = /* @__PURE__ */ new Map();
+    this.held = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Map();
+    this.lazy = /* @__PURE__ */ new Set();
+  }
+  use(chunk, lazy) {
+    lazy ? this.lazy.add(chunk) : this.users.set(chunk, (this.users.get(chunk) ?? 0) + 1);
+  }
+  register(manifest, parts) {
+    this.use(manifest.chunk, manifest.lazy === true);
+    for (let part of parts) this.use(part.chunk, part.lazy === true);
+  }
+  holds(digest) {
+    return this.held.has(digest);
+  }
+  fetch(digest, priority, source) {
+    let held = this.held.get(digest);
+    if (held !== void 0) return Promise.resolve(held);
+    let loading = this.loading.get(digest);
+    if (loading !== void 0) return loading;
+    let taken = source.take(digest, priority).then((payload) => (this.loading.delete(digest), !this.lazy.has(digest) && (this.users.get(digest) ?? 0) > 1 && this.held.set(digest, payload), payload));
+    return taken.catch(() => this.loading.delete(digest)), this.loading.set(digest, taken), taken;
+  }
+  shared(digest) {
+    return this.lazy.has(digest) || (this.users.get(digest) ?? 0) > 1;
+  }
+  done(digest, source) {
+    if (this.lazy.has(digest)) {
+      source.release(digest);
+      return;
+    }
+    let left = (this.users.get(digest) ?? 0) - 1;
+    if (left > 0) {
+      this.users.set(digest, left);
+      return;
+    }
+    this.users.delete(digest), this.held.delete(digest);
+  }
+  async stream(manifestDigest, priority, refine, source, feed) {
+    let manifest = decodeManifest(await this.fetch(manifestDigest, priority, source)), bodies = /* @__PURE__ */ new Map(), body = (part, at) => {
+      let known = bodies.get(part);
+      if (known !== void 0) return known;
+      let loading = this.fetch(manifest.parts[part].digest, at, source).then((payload) => decodePart(payload).body);
+      return loading.catch(() => {
+      }), bodies.set(part, loading), loading;
+    }, scheduled = false, scratch = new Uint8Array(0);
+    try {
+      let at = 0;
+      for (let index = 0; index < manifest.segments.length; index++) {
+        let s = manifest.segments[index];
+        if (feed.cancelled) return;
+        if (!scheduled && feed.firstBytes >= 0) {
+          scheduled = !0;
+          let offset = at;
+          for (let i = index; i < manifest.segments.length; i++) {
+            let next = manifest.segments[i];
+            next.op !== SegmentOp.literal && body(next.part, offset < feed.firstBytes ? priority : refine), offset += segmentOutput(next);
+          }
+        }
+        if (s.op === SegmentOp.literal)
+          feed.push(manifest.literal.subarray(s.offset, s.offset + s.length));
+        else if (s.op === SegmentOp.part) {
+          let part = await body(s.part, priority);
+          if (part.length !== manifest.parts[s.part].length) throw new PartFormatError(`part ${manifest.parts[s.part].digest} is ${part.length} bytes, not ${manifest.parts[s.part].length}`);
+          feed.push(part.subarray(s.offset, s.offset + s.length));
+        } else {
+          let base = await body(s.part, priority);
+          scratch.length < s.output && (scratch = new Uint8Array(s.output)), applyDelta(base, manifest.literal.subarray(s.offset, s.offset + s.length), scratch, 0, s.output), feed.push(scratch.subarray(0, s.output));
+        }
+        at += segmentOutput(s);
+      }
+    } finally {
+      for (let p of manifest.parts) this.done(p.digest, source);
+      this.done(manifestDigest, source);
+    }
+  }
+  async assemble(manifestDigest, priority, source) {
+    let manifest = decodeManifest(await this.fetch(manifestDigest, priority, source)), bodies = (await Promise.all(manifest.parts.map((p) => this.fetch(p.digest, priority, source)))).map((payload) => decodePart(payload).body), sole = soleSpan(manifest), out;
+    if (sole !== null) {
+      let view = bodies[sole.part].subarray(sole.offset, sole.offset + manifest.length);
+      out = this.shared(manifest.parts[sole.part].digest) ? view.slice() : view;
+    } else
+      out = new Uint8Array(manifest.length), assembleInto(manifest, (index) => bodies[index], out, 0);
+    for (let p of manifest.parts) this.done(p.digest, source);
+    return this.done(manifestDigest, source), out;
+  }
+};
+
+// src/interactives/runtime/assets.ts
+var MODULE_KEY_SEPARATOR = ",", CONTENT_PREFIX = "content/", TIERED_CONTENT = /^content@(low|mid|high)\/(.+)$/, DIGEST = /^[0-9a-f]{64}$/, PackageAssets = class {
+  constructor(joinedSource = null, compiler = null) {
+    this.joinedSource = joinedSource;
+    this.compiler = compiler;
+    this.arrived = /* @__PURE__ */ new Map();
+    this.tiered = /* @__PURE__ */ new Map();
+    this.waiting = /* @__PURE__ */ new Map();
+    this.paths = /* @__PURE__ */ new Map();
+    this.modules = /* @__PURE__ */ new Map();
+    this.lazyDigests = /* @__PURE__ */ new Set();
+    this.prefetching = /* @__PURE__ */ new Map();
+    this.prefetched = /* @__PURE__ */ new Set();
+    this.cancelled = /* @__PURE__ */ new Set();
+    this.networkListeners = [];
+    this.parted = /* @__PURE__ */ new Map();
+    this.assetParts = new AssetParts();
+    this.progressiveAssets = /* @__PURE__ */ new Set();
+    this.channel = null;
+    this.hint = null;
+    this.catalogPending = null;
+    this.catalogDone = () => {
+    };
+  }
+  joined(sha256, parts) {
+    if (this.joinedSource === null) return null;
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let compiled = this.joinedSource(sha256, parts);
+    return compiled.catch(() => this.modules.delete(key)), this.modules.set(key, compiled), compiled;
+  }
+  warm(parts, compile) {
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let binary = this.binary(parts);
+    if (binary === null) return null;
+    let compiled = compile(binary);
+    return compiled.catch(() => {
+    }), this.modules.set(key, compiled), compiled;
+  }
+  binary(parts) {
+    let bytes = 0;
+    for (let part of parts) {
+      let staged = this.arrived.get(part);
+      if (staged === void 0) return null;
+      bytes += staged.length;
+    }
+    return { parts, bytes };
+  }
+  module(parts) {
+    let key = parts.join(MODULE_KEY_SEPARATOR), known = this.modules.get(key);
+    if (known !== void 0) return known;
+    let compiler = this.compiler;
+    if (compiler === null) return null;
+    let compiled = this.joinTaken(parts).then(compiler);
+    return compiled.catch(() => this.modules.delete(key)), this.modules.set(key, compiled), compiled;
+  }
+  async joinTaken(parts) {
+    let taken = [], length = 0;
+    for (let part of parts) {
+      let bytes = await this.take(part);
+      taken.push(bytes), length += bytes.length;
+    }
+    if (taken.length === 1) return taken[0];
+    let joined = new Uint8Array(length), at = 0;
+    for (let bytes of taken)
+      joined.set(bytes, at), at += bytes.length;
+    return joined;
+  }
+  catalog(assets) {
+    for (let asset of assets) {
+      if (this.paths.set(asset.path, asset.chunk), asset.lazy === true && this.lazyDigests.add(asset.chunk), asset.progressive === true && this.progressiveAssets.add(asset.path), asset.parts !== void 0) {
+        this.parted.set(asset.path, asset.parts), this.assetParts.register(asset, asset.parts);
+        for (let part of asset.parts) part.lazy === true && this.lazyDigests.add(part.chunk);
+      }
+      let tiered = TIERED_CONTENT.exec(asset.path);
+      if (tiered === null) continue;
+      let plain = `${CONTENT_PREFIX}${tiered[2]}`, known = this.tiered.get(plain) ?? [];
+      known.push(asset.chunk), this.tiered.set(plain, known);
+    }
+  }
+  awaitCatalog() {
+    this.catalogPending === null && (this.catalogPending = new Promise((resolve) => {
+      this.catalogDone = resolve;
+    }));
+  }
+  catalogued() {
+    this.catalogPending = null, this.catalogDone();
+  }
+  /** An asset the follow index will catalog: not known yet, and not a chunk digest. */
+  uncatalogued(asset) {
+    return this.catalogPending === null || this.has(asset) || DIGEST.test(asset) ? null : this.catalogPending;
+  }
+  has(asset) {
+    return this.paths.has(asset) || this.tiered.has(asset);
+  }
+  resolve(asset) {
+    let alternatives = this.tiered.get(asset);
+    if (alternatives !== void 0) {
+      for (let digest of alternatives) if (this.arrived.has(digest)) return digest;
+    }
+    return this.paths.get(asset) ?? asset;
+  }
+  accept(digest, payload) {
+    let waiter = this.waiting.get(digest);
+    if (waiter !== void 0) {
+      this.waiting.delete(digest), waiter.needed && chunkResolved(), waiter.resolve(payload.slice());
+      return;
+    }
+    if (this.cancelled.delete(digest)) {
+      this.channel?.release(digest);
+      return;
+    }
+    this.prefetching.delete(digest) && this.prefetched.add(digest), this.arrived.has(digest) || this.arrived.set(digest, payload.slice());
+  }
+  connect(channel) {
+    this.channel = channel;
+  }
+  network(hint) {
+    this.hint = hint;
+    for (let i = 0; i < this.networkListeners.length; i++) this.networkListeners[i](hint);
+  }
+  networkHint() {
+    return this.hint;
+  }
+  onNetwork(listener) {
+    return this.networkListeners.push(listener), () => {
+      let at = this.networkListeners.indexOf(listener);
+      at >= 0 && this.networkListeners.splice(at, 1);
+    };
+  }
+  fail(digest, reason) {
+    this.prefetching.delete(digest), this.cancelled.delete(digest);
+    let waiter = this.waiting.get(digest);
+    waiter !== void 0 && (this.waiting.delete(digest), waiter.needed && chunkResolved(), waiter.reject(new ChunkUnavailable(digest, reason)));
+  }
+  prefetch(asset, priority = ChunkPriority.prefetch) {
+    let later = this.uncatalogued(asset);
+    if (later !== null)
+      return later.then(() => this.prefetch(asset, priority)), true;
+    let parts = this.parted.get(asset);
+    if (parts !== void 0) for (let part of parts) part.lazy === true && !this.assetParts.holds(part.chunk) && this.prefetch(part.chunk, priority);
+    let digest = this.resolve(asset), channel = this.channel;
+    if (channel === null || !this.lazyDigests.has(digest)) return false;
+    if (this.arrived.has(digest) || this.waiting.has(digest)) return true;
+    let known = this.prefetching.get(digest);
+    return known !== void 0 && known <= priority || (this.cancelled.delete(digest), this.prefetching.set(digest, priority), channel.request(digest, priority)), true;
+  }
+  cancelPrefetch(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0) for (let part of parts) part.lazy === true && this.cancelPrefetch(part.chunk);
+    let digest = this.resolve(asset), channel = this.channel;
+    return channel === null ? false : this.prefetching.delete(digest) ? (this.cancelled.add(digest), channel.release(digest), true) : this.prefetched.delete(digest) ? (this.arrived.delete(digest), channel.release(digest), true) : false;
+  }
+  resident(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0 && !parts.every((part) => this.arrived.has(part.chunk) || this.assetParts.holds(part.chunk))) return false;
+    let digest = this.resolve(asset);
+    return this.arrived.has(digest) || this.assetParts.holds(digest);
+  }
+  pending(asset) {
+    let parts = this.parted.get(asset);
+    if (parts !== void 0 && parts.some((part) => this.pending(part.chunk))) return true;
+    let digest = this.resolve(asset);
+    return this.prefetching.has(digest) || this.waiting.has(digest);
+  }
+  lazy(asset) {
+    return this.lazyDigests.has(this.resolve(asset));
+  }
+  requests() {
+    return this.channel !== null;
+  }
+  isProgressive(asset) {
+    return this.progressiveAssets.has(asset);
+  }
+  progressive(asset, listener = null, priority = ChunkPriority.now, refine = ChunkPriority.soon) {
+    let feed = new ProgressiveFeed(asset, listener), later = this.uncatalogued(asset);
+    return later !== null ? (priority === ChunkPriority.now && chunkNeeded(), later.then(() => {
+      priority === ChunkPriority.now && chunkResolved(), this.feedProgressive(feed, asset, priority, refine);
+    }), feed) : (this.feedProgressive(feed, asset, priority, refine), feed);
+  }
+  feedProgressive(feed, asset, priority, refine) {
+    if (!this.progressiveAssets.has(asset)) {
+      this.takeStored(asset, priority, priority === ChunkPriority.now).then(
+        (bytes) => feed.complete(bytes),
+        (error) => feed.fail(error)
+      );
+      return;
+    }
+    if (!this.parted.has(asset)) {
+      this.takeStored(asset, priority, priority === ChunkPriority.now).then(
+        (bytes) => feed.whole(bytes),
+        (error) => feed.fail(error)
+      );
+      return;
+    }
+    let stall = priority === ChunkPriority.now, source = { take: (digest, at) => this.takeStored(digest, at, stall && at === priority), release: (digest) => this.release(digest) };
+    this.assetParts.stream(this.resolve(asset), priority, refine, source, feed).catch((error) => feed.fail(error));
+  }
+  take(asset, priority = ChunkPriority.now, stall = priority === ChunkPriority.now) {
+    let later = this.uncatalogued(asset);
+    if (later !== null)
+      return stall && chunkNeeded(), later.then(() => (stall && chunkResolved(), this.take(asset, priority, stall)));
+    let stored = this.takeStored(asset, priority, stall);
+    return this.progressiveAssets.has(asset) ? stored.then(decodeProgressive) : stored;
+  }
+  takeStored(asset, priority, stall) {
+    if (this.parted.has(asset)) {
+      let source = { take: (digest2, at) => this.takeStored(digest2, at, stall), release: (digest2) => this.release(digest2) };
+      return this.assetParts.assemble(this.resolve(asset), priority, source);
+    }
+    let digest = this.resolve(asset), bytes = this.arrived.get(digest);
+    if (bytes !== void 0)
+      return this.arrived.delete(digest), this.prefetched.delete(digest), Promise.resolve(bytes);
+    if (this.waiting.has(digest)) return Promise.reject(new Error(`chunk ${digest} is already being awaited`));
+    let prefetching = this.prefetching.get(digest);
+    this.prefetching.delete(digest);
+    let requestable = this.channel !== null && this.lazyDigests.has(digest), needed = requestable && stall;
+    return new Promise((resolve, reject) => {
+      this.waiting.set(digest, { resolve, reject, needed }), needed && chunkNeeded(), requestable && (prefetching === void 0 || priority < prefetching) && this.channel?.request(digest, priority);
+    });
+  }
+  release(asset) {
+    let digest = this.resolve(asset);
+    this.prefetched.delete(digest) && this.arrived.delete(digest), this.channel !== null && this.lazyDigests.has(digest) && this.channel.release(digest);
+  }
+}, ChunkUnavailable = class extends Error {
+  constructor(digest, reason) {
+    super(`the host could not deliver chunk ${digest} (${reason})`);
+    this.digest = digest;
+    this.reason = reason;
+    this.name = "ChunkUnavailable";
+  }
+};
+
+// src/interactives/runtime/frame-loop.ts
+var FIXED_STEP_MS = 16.666666666666668;
+
+export { FIXED_STEP_MS, PackageAssets };

package/dist/chunk-UGH37BQW.mjs

@@ -0,0 +1,157 @@
+import { TAG_BYTES, MessageTag, BRIDGE_LIMITS } from './chunk-V7ZRH3PY.mjs';
+
+// src/interactives/runtime/tree.ts
+var TreeError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "TreeError";
+  }
+}, NO_PROPS = "", EMPTY = [];
+function childrenOf(node) {
+  return node.children ?? EMPTY;
+}
+var Budget = class {
+  constructor() {
+    this.nodes = 0;
+  }
+  admit(depth) {
+    if (this.nodes += 1, this.nodes > BRIDGE_LIMITS.max_tree_nodes)
+      throw new TreeError(`a tree may hold at most ${BRIDGE_LIMITS.max_tree_nodes} nodes`);
+    if (depth > BRIDGE_LIMITS.max_tree_depth)
+      throw new TreeError(`a tree may nest at most ${BRIDGE_LIMITS.max_tree_depth} levels`);
+  }
+};
+function shadowOf(node, depth, budget) {
+  if (typeof node != "object" || node === null || typeof node.type != "string")
+    throw new TreeError("every tree node needs a string type");
+  budget.admit(depth);
+  let shadows = childrenOf(node).map((child) => shadowOf(child, depth + 1, budget));
+  return {
+    type: node.type,
+    key: node.key ?? null,
+    props: node.props === void 0 ? NO_PROPS : JSON.stringify(node.props),
+    children: shadows
+  };
+}
+function sameIdentity(a, b) {
+  return a.type === b.type && a.key === b.key;
+}
+var TreeDiffer = class {
+  constructor() {
+    this.shadow = null;
+  }
+  diff(next) {
+    let patches = [];
+    if (next === null)
+      return this.shadow !== null && patches.push({ op: "root", node: null }), this.shadow = null, patches;
+    let shadow = shadowOf(next, 0, new Budget()), previous = this.shadow;
+    return this.shadow = shadow, previous === null || !sameIdentity(previous, shadow) ? (patches.push({ op: "root", node: next }), patches) : (walk(previous, shadow, next, [], patches), patches);
+  }
+};
+function walk(previous, current, node, at, patches) {
+  previous.props !== current.props && patches.push({ op: "props", at: at.slice(), props: node.props ?? null });
+  let before = previous.children, after = current.children, nodes = childrenOf(node), head = 0, shortest = before.length < after.length ? before.length : after.length;
+  for (; head < shortest && sameIdentity(before[head], after[head]); ) head++;
+  let tail = 0;
+  for (; tail < shortest - head && sameIdentity(before[before.length - 1 - tail], after[after.length - 1 - tail]); )
+    tail++;
+  for (let i = 0; i < head; i++)
+    at.push(i), walk(before[i], after[i], nodes[i], at, patches), at.pop();
+  let removed = before.length - head - tail, inserted = after.length - head - tail;
+  if (removed > 0 || inserted > 0) {
+    let insert = nodes.slice(head, head + inserted);
+    patches.push({ op: "splice", at: at.slice(), start: head, remove: removed, insert });
+  }
+  for (let i = 0; i < tail; i++) {
+    let was = before.length - tail + i, now = after.length - tail + i;
+    at.push(now), walk(before[was], after[now], nodes[now], at, patches), at.pop();
+  }
+}
+function withChildren(node, children) {
+  let out = { type: node.type };
+  return node.key !== void 0 && (out.key = node.key), node.props !== void 0 && (out.props = node.props), children.length > 0 && (out.children = children), out;
+}
+function update(node, at, depth, change) {
+  if (depth === at.length) return change(node);
+  let children = childrenOf(node), index = at[depth];
+  if (index < 0 || index >= children.length) throw new TreeError("a patch names a node that does not exist");
+  let next = children.slice();
+  return next[index] = update(children[index], at, depth + 1, change), withChildren(node, next);
+}
+var TreeMirror = class {
+  constructor() {
+    this.current = null;
+  }
+  get root() {
+    return this.current;
+  }
+  apply(patches) {
+    let root = this.current;
+    for (let patch of patches) {
+      if (patch.op === "root") {
+        root = patch.node;
+        continue;
+      }
+      if (root === null) throw new TreeError("a patch arrived before the first tree");
+      root = update(root, patch.at, 0, (target) => {
+        switch (patch.op) {
+          case "replace":
+            return patch.node;
+          case "props": {
+            let out = { type: target.type };
+            return target.key !== void 0 && (out.key = target.key), patch.props !== null && (out.props = patch.props), target.children !== void 0 && (out.children = target.children), out;
+          }
+          case "splice": {
+            let children = childrenOf(target).slice();
+            return children.splice(patch.start, patch.remove, ...patch.insert), withChildren(target, children);
+          }
+        }
+      });
+    }
+    return this.current = root, root;
+  }
+};
+
+// src/interactives/runtime/clip-wire.ts
+var DEFAULT_CLIP_WINDOW_MS = 15e3, DEFAULT_CLIP_FPS = 30, DEFAULT_CLIP_VIDEO_BITS = 4e6, DEFAULT_CLIP_LONG_EDGE = 1280, DEFAULT_CLIP_ARM = {
+  window_ms: (15e3),
+  fps: (30),
+  video_bits_per_second: (4e6),
+  audio: true,
+  max_long_edge: (1280)
+}, ClipStatus = { saved: 0, empty: 1, unavailable: 2 }, CLIP_PAUSE_BYTES = TAG_BYTES + 1, CLIP_SAVE_BYTES = TAG_BYTES + 8, SAVED_ID = TAG_BYTES, SAVED_STATUS = SAVED_ID + 4, SAVED_DURATION = SAVED_STATUS + 1, SAVED_WIDTH = SAVED_DURATION + 4, SAVED_HEIGHT = SAVED_WIDTH + 2, SAVED_TYPE_LENGTH = SAVED_HEIGHT + 2, CLIP_SAVED_HEADER_BYTES = SAVED_TYPE_LENGTH + 1;
+var LITTLE_ENDIAN = true, REPLAY_HEADER_BYTES = TAG_BYTES + 1, REPLAY_WATCH = 0, REPLAY_PLAY = 1;
+function replayMessage(replay, mode) {
+  let out = new Uint8Array(REPLAY_HEADER_BYTES + replay.length);
+  return out[0] = MessageTag.replay, out[TAG_BYTES] = mode === "play" ? (1) : (0), out.set(replay, REPLAY_HEADER_BYTES), out;
+}
+function readReplayMessage(bytes) {
+  return bytes.length < REPLAY_HEADER_BYTES || bytes[0] !== MessageTag.replay ? null : { replay: bytes.slice(REPLAY_HEADER_BYTES), mode: bytes[TAG_BYTES] === (1) ? "play" : "watch" };
+}
+function writeClipPause(out, paused) {
+  return out[0] = MessageTag.clip_pause, out[TAG_BYTES] = paused ? 1 : 0, CLIP_PAUSE_BYTES;
+}
+function writeClipSave(out, id, keep_ms) {
+  let view = new DataView(out.buffer, out.byteOffset, CLIP_SAVE_BYTES);
+  return out[0] = MessageTag.clip_save, view.setUint32(TAG_BYTES, id >>> 0, (true)), view.setUint32(TAG_BYTES + 4, Math.max(0, Math.round(keep_ms)) >>> 0, (true)), CLIP_SAVE_BYTES;
+}
+function readClipSaved(bytes) {
+  if (bytes.length < CLIP_SAVED_HEADER_BYTES || bytes[0] !== MessageTag.clip_saved) return null;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), length = view.getUint8(SAVED_TYPE_LENGTH), bodyAt = CLIP_SAVED_HEADER_BYTES + length;
+  if (bytes.length < bodyAt) return null;
+  let type = "";
+  for (let i = 0; i < length; i++) type += String.fromCharCode(bytes[CLIP_SAVED_HEADER_BYTES + i]);
+  let status = view.getUint8(SAVED_STATUS);
+  return {
+    header: {
+      id: view.getUint32(SAVED_ID, (true)),
+      status: status <= ClipStatus.unavailable ? status : ClipStatus.unavailable,
+      duration_ms: view.getUint32(SAVED_DURATION, (true)),
+      width: view.getUint16(SAVED_WIDTH, (true)),
+      height: view.getUint16(SAVED_HEIGHT, (true)),
+      type
+    },
+    body: bytes.subarray(bodyAt)
+  };
+}
+
+export { CLIP_PAUSE_BYTES, CLIP_SAVE_BYTES, ClipStatus, DEFAULT_CLIP_ARM, TreeDiffer, TreeError, TreeMirror, readClipSaved, readReplayMessage, replayMessage, writeClipPause, writeClipSave };