MeshedFlow turns live audiences into delivery capacity.

// Same account-gated access object used by the ProofOfConcept demo.
import shaka from 'shaka-player/dist/shaka-player.ui.js';
import { MeshedFlowLoader } from '@meshedflow/sdk';

const MESH_SCHEME = 'meshedflow';
const access = await fetch('/api/video/access', {
  credentials: 'include',
}).then(assertOk);

const mesh = new MeshedFlowLoader({
  signalingUrl: access.signalingUrl,
  originBaseUrl: location.origin,
  telemetryEndpoint: `${location.origin}/telemetry`,
  streamId: access.streamId,
  peerId: access.peerId,
  authToken: access.authToken,
  rendition: access.rendition,
  videoElement,
  manifestPublicKey: access.manifestPublicKey,
  requireManifestSignature: access.requireManifestSignature === true,
  autoFetchManifestPublicKey: true,
  segmentUrlNormalizer: normalizeMeshSegmentUrl,
});

const player = new shaka.Player(videoElement);
player.configure(createShakaRightsConfig({
  keySystem: access.keySystem,
  licenseUrl: access.licenseUrl,
}));

const net = player.getNetworkingEngine();
net.registerRequestFilter((type, request) => {
  if (type === shaka.net.NetworkingEngine.RequestType.LICENSE) {
    request.allowCrossSiteCredentials = true;
  }

  if (type === shaka.net.NetworkingEngine.RequestType.SEGMENT) {
    request.uris = request.uris.map((uri) =>
      `${MESH_SCHEME}:${encodeURIComponent(uri)}`
    );
  }
});

shaka.net.NetworkingEngine.registerScheme(MESH_SCHEME, (uri, request) => {
  const originalUrl = decodeURIComponent(uri.slice(`${MESH_SCHEME}:`.length));
  const range = dashRangeFromHeaders(request.headers || {});
  const context = {
    url: meshUrlWithRange(originalUrl, range),
    responseType: 'arraybuffer',
  };

  let handle;
  const promise = new Promise((resolve, reject) => {
    handle = mesh.load(context, {}, { onSuccess: resolve, onError: reject });
  });

  return new shaka.util.AbortableOperation(promise, () => {
    handle?.abort?.();
    return Promise.resolve();
  });
});

await player.load(access.manifestUrl);