@misofm/platform 0.19.0 → 0.21.0

package/src/publication.ts

@@ -48,11 +48,13 @@ import {
 } from "./credits.ts";
 import {
   setRecordingAdvisory,
+  setRecordingEngineSession,
   setRecordingInstrumental,
   setRecordingLanguages,
   setRecordingMasterReference,
   setRecordingStreamingTranscode,
 } from "./recording-extensions.ts";
+import { unencryptedWalrusBlob } from "./internal.ts";
 import {
   setReleaseDescription,
   setReleaseDspLinks,
@@ -148,6 +150,20 @@ type PublicationRecordingParent =
   | { readonly parentCompositionIndex: number; readonly parentCompositionId?: never }
   | { readonly parentCompositionIndex?: never; readonly parentCompositionId: string };
 
+/** One stem a Session V1 document references, paired with its Walrus blob. */
+export interface PublicationEngineSessionStem {
+  /** 32-byte SHA-256 of the stem's canonical PCM (engine STEM_IDENTITY_V1); bytes or 64 hex chars. */
+  readonly digest: Uint8Array | string;
+  /** Unencrypted Walrus blob holding the stem's FLAC, as its on-chain `u256`. */
+  readonly blobId: bigint | string;
+}
+
+export interface PublicationEngineSession {
+  /** Unencrypted Walrus blob holding the canonical Session V1 JSON, as its on-chain `u256`. */
+  readonly sessionBlobId: bigint | string;
+  readonly stems: readonly PublicationEngineSessionStem[];
+}
+
 export type PublicationRecordingLanguages =
   | { readonly kind: "instrumental" }
   | { readonly kind: "languages"; readonly codes: string[] };
@@ -171,6 +187,8 @@ export type PublicationRecording = PublicationRecordingParent & {
   readonly masterReferenceBlobId?: bigint | string;
   /** Complete Walrus Quilt ID containing this Recording's streaming transcodes. */
   readonly streamingTranscodeQuiltId?: bigint | string;
+  /** This Recording's Miso Engine session: the Session V1 blob and every stem it plays. */
+  readonly engineSession?: PublicationEngineSession;
 };
 
 export interface PublicationFreshTrack {
@@ -332,10 +350,7 @@ function languageVector(tx: Transaction, p: AtomicPublicationParams, codes: stri
 }
 
 function walrusBlob(tx: Transaction, p: AtomicPublicationParams, blobId: bigint | string) {
-  return tx.moveCall({
-    target: `${p.deployment.packages.ori}::walrus_data::new_blob`,
-    arguments: [tx.pure.u256(blobId)],
-  });
+  return unencryptedWalrusBlob(tx, p.deployment.packages.ori, blobId);
 }
 
 function listingPrice(tx: Transaction, p: AtomicPublicationParams, price: ListingPrice) {
@@ -652,6 +667,14 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
       "A recording streaming transcode requires deployment.packages.recordingStreamingTranscode",
     );
   }
+  if (
+    p.recordings.some((node) => node.engineSession !== undefined) &&
+    !p.deployment.packages.recordingEngineSession
+  ) {
+    throw new Error(
+      "A recording engine session requires deployment.packages.recordingEngineSession",
+    );
+  }
   if (publicationUsesVault(p)) {
     requireOperationsDeployment(p.deployment.operations);
   }
@@ -869,6 +892,15 @@ export function publishAtomicCatalog(p: AtomicPublicationParams): TxThunk {
         oriPackageId: p.deployment.packages.ori,
         quiltId: node.streamingTranscodeQuiltId,
       })(tx);
+      if (node.engineSession !== undefined) setRecordingEngineSession({
+        recordingId: parts.work, authority,
+        recordingShareType: node.shareType,
+        compositionShareType: node.compositionShareType,
+        recordingEngineSessionPackageId: p.deployment.packages.recordingEngineSession!,
+        oriPackageId: p.deployment.packages.ori,
+        sessionBlobId: node.engineSession.sessionBlobId,
+        stems: node.engineSession.stems,
+      })(tx);
     });
 
     if (p.release && releaseObject && releaseAdminCap) {

package/src/read/catalog.ts

@@ -38,10 +38,6 @@ import {
   releaseKindFieldId,
 } from "../release-extensions.ts";
 import { getRecordingMasterReferencesByIds } from "../recording-extensions.ts";
-import {
-  getReleaseMixReferences,
-  walrusBlobIdFromU256,
-} from "../mix.ts";
 import { getTrackCreditsByRecordingIds } from "../catalog.ts";
 import { getReleaseById, getReleasesByIds, isNotFound } from "@misofm/protocol";
 import type { Release } from "@misofm/protocol";
@@ -49,7 +45,6 @@ import type { MisoClient } from "./client.ts";
 import { getRecordingTitles, parseReleaseObject } from "./works.ts";
 import { int } from "./internal/scalars.ts";
 import {
-  quiltPatchId,
   u256ToB64Url,
   walrusBlobReadUrl,
 } from "./internal/walrus.ts";
@@ -75,17 +70,9 @@ import type {
 
 // ── Walrus URLs ──────────────────────────────────────────────────────────────
 
-/** Aggregator URL for a cover image ref, whichever Walrus variant it is. */
+/** Aggregator URL for a cover image ref (a standalone Walrus blob). */
 function imageUrl(aggregator: string, ref: CoverImageRef): string {
-  const base = aggregator.replace(/\/$/, "");
-  if (ref.kind === "blob") return walrusBlobReadUrl(base, ref.blobId);
-  const patch = quiltPatchId(
-    ref.quiltId,
-    ref.version,
-    ref.startIndex,
-    ref.endIndex,
-  );
-  return `${base}/v1/blobs/by-quilt-patch-id/${patch}`;
+  return walrusBlobReadUrl(aggregator.replace(/\/$/, ""), ref.blobId);
 }
 
 function toCover(
@@ -212,11 +199,9 @@ export function toTracks(
   release: Release,
   titles: Record<string, string>,
   masterBlobIds: Partial<Record<string, string>>,
-  mixBlobIds: Partial<Record<number, string>> = {},
 ): TrackView[] {
   return release.tracks.map((track, index) => {
     const masterBlobId = masterBlobIds[track.recordingId];
-    const mixBlobId = mixBlobIds[index];
     return {
       no: `${index + 1}`,
       title: titles[track.recordingId] ?? "Untitled",
@@ -225,7 +210,6 @@ export function toTracks(
       splitBps: int(track.splitBps.value),
       disc: 1,
       ...(masterBlobId ? { masterBlobId } : {}),
-      ...(mixBlobId ? { mixBlobId } : {}),
     };
   });
 }
@@ -373,8 +357,7 @@ export async function getReleaseDetail(
   );
 
   const recordingIds = release.tracks.map((track) => track.recordingId);
-  const mixPackageId = client.config.protocol.releaseMixReference;
-  const [titles, masterReferences, mixReferences, trackCredits] = await Promise.all([
+  const [titles, masterReferences, trackCredits] = await Promise.all([
     getRecordingTitles(
       client.protocol,
       client.graphql,
@@ -386,9 +369,6 @@ export async function getReleaseDetail(
       recordingIds,
       client.config.protocol.recordingMasterReference,
     ).catch(() => ({})),
-    mixPackageId
-      ? getReleaseMixReferences(client.protocol, releaseId, mixPackageId).catch(() => null)
-      : Promise.resolve(null),
     options.include?.includes("trackCredits")
       ? getTrackCreditsForRecordingIds(client, recordingIds)
       : Promise.resolve(undefined),
@@ -397,11 +377,6 @@ export async function getReleaseDetail(
   for (const [recordingId, blobId] of Object.entries(masterReferences)) {
     if (blobId) masterBlobIds[recordingId] = u256ToB64Url(blobId);
   }
-  const mixBlobIds: Record<number, string> = {};
-  for (let index = 0; index < (mixReferences?.length ?? 0); index += 1) {
-    const reference = mixReferences?.[index];
-    if (reference) mixBlobIds[index] = walrusBlobIdFromU256(reference.blobId);
-  }
 
   const creditViews = credits ?? [];
   return {
@@ -416,7 +391,7 @@ export async function getReleaseDetail(
     credits: creditViews,
     primaryArtists: primaryArtistNames(creditViews),
     discCount: release.tracks.length > 0 ? 1 : 0,
-    tracks: toTracks(release, titles, masterBlobIds, mixBlobIds),
+    tracks: toTracks(release, titles, masterBlobIds),
     ...(trackCredits !== undefined ? { trackCredits } : {}),
   };
 }

package/src/read/config.ts

@@ -33,8 +33,6 @@ export interface ProtocolIds {
   releaseKind: string;
   /** `recording_master_reference` — optional Walrus master pointers. */
   recordingMasterReference: string;
-  /** `release_mix_reference` — optional per-track delivery descriptor pointers. */
-  releaseMixReference?: string;
   /** `composition_credits` / `recording_credits` / `release_credits` extensions. */
   compositionCredits: string;
   recordingCredits: string;

package/src/read/internal/walrus.ts

@@ -3,7 +3,7 @@
 
 import { bcs } from "@mysten/sui/bcs";
 import { toBase64 } from "@mysten/sui/utils";
-import { walrusBlobIdFromU256 } from "../../mix.ts";
+import { walrusBlobIdFromU256 } from "../../walrus-ids.ts";
 
 const u256 = bcs.u256();
 

package/src/read/types.ts

@@ -76,8 +76,6 @@ export interface TrackView {
   disc: number;
   /** Base64url Walrus blob id for the master stream, when attached on-chain. */
   masterBlobId?: string;
-  /** Base64url Walrus blob id for the public mix-delivery descriptor. */
-  mixBlobId?: string;
 }
 
 /** A release with everything a page renders: metadata, cover, credits, tracklist. */

package/src/recording-extensions.ts

@@ -6,14 +6,17 @@
 import { bcs } from "@mysten/sui/bcs";
 import type { ClientWithCoreApi } from "@mysten/sui/client";
 import type { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
-import { deriveDynamicFieldID } from "@mysten/sui/utils";
+import { deriveDynamicFieldID, fromHex, toHex } from "@mysten/sui/utils";
+import { isNotFound } from "@misofm/protocol";
 import type { TxThunk } from "./transactions.ts";
 import { invokeWithAdminCap, type AdminCapAuthority, type ObjectInput } from "./vault.ts";
 import * as advisory from "@misofm/protocol/contracts/recording_advisory/recording_advisory";
 import * as language from "@misofm/protocol/contracts/recording_language/recording_language";
-import * as walrusData from "@misofm/protocol/contracts/recording_master_reference/deps/ori/walrus_data";
+import * as walrusData from "@misofm/protocol/contracts/recording_master_reference/deps/ori/data";
 import * as masterReference from "@misofm/protocol/contracts/recording_master_reference/recording_master_reference";
+import * as engineSession from "@misofm/protocol/contracts/recording_engine_session/recording_engine_session";
 import * as streamingTranscode from "@misofm/protocol/contracts/recording_streaming_transcode/recording_streaming_transcode";
+import { unencryptedWalrusBlob } from "./internal.ts";
 
 export interface RecordingExtensionTarget {
   readonly recordingId: ObjectInput;
@@ -77,7 +80,7 @@ export function setRecordingInstrumental(p: Omit<SetRecordingLanguagesParams, "l
 }
 
 interface RecordingWalrusReferenceParams extends RecordingExtensionTarget {
-  /** An ori::WalrusData value assembled in the same PTB (must be a standalone blob on chain). */
+  /** An `ori::data::WalrusBlob` value assembled in the same PTB. */
   readonly reference: TransactionArgument;
 }
 
@@ -130,6 +133,100 @@ export type UnsetRecordingStreamingTranscodeParams = Omit<
   "oriPackageId" | "quiltId"
 >;
 
+/** One stem a Session V1 document references, paired with its Walrus blob. */
+export interface RecordingEngineSessionStemInput {
+  /** 32-byte SHA-256 of the stem's canonical PCM (engine STEM_IDENTITY_V1): raw bytes or 64 hex chars. */
+  readonly digest: Uint8Array | string;
+  /** Unencrypted Walrus blob holding the stem's FLAC, as its on-chain `u256`. */
+  readonly blobId: bigint | string;
+}
+
+export interface SetRecordingEngineSessionParams extends RecordingExtensionTarget {
+  readonly recordingEngineSessionPackageId: string;
+  /** External `ori` package used to construct the plaintext Walrus blob references. */
+  readonly oriPackageId: string;
+  /** Unencrypted Walrus blob holding the canonical Session V1 JSON, as its on-chain `u256`. */
+  readonly sessionBlobId: bigint | string;
+  /** Every stem the document's sources reference. Order does not matter; the builder sorts. */
+  readonly stems: readonly RecordingEngineSessionStemInput[];
+}
+
+const STEM_DIGEST_BYTES = 32;
+
+function stemDigestBytes(digest: Uint8Array | string): Uint8Array {
+  const bytes = typeof digest === "string" ? fromHex(digest) : digest;
+  if (bytes.length !== STEM_DIGEST_BYTES) {
+    throw new Error(`stem digest must be ${STEM_DIGEST_BYTES} bytes`);
+  }
+  return bytes;
+}
+
+function compareBytes(a: Uint8Array, b: Uint8Array): number {
+  for (let index = 0; index < a.length; index += 1) {
+    if (a[index] !== b[index]) return a[index]! - b[index]!;
+  }
+  return 0;
+}
+
+/**
+ * Sets or replaces the Miso Engine session attached to a Recording: the
+ * Session V1 blob plus one `Stem` per source. Stems are sorted by digest and
+ * checked for duplicates here, mirroring `recording_engine_session::new`, so a
+ * bad input fails before signing rather than on chain.
+ */
+export function setRecordingEngineSession(p: SetRecordingEngineSessionParams): TxThunk {
+  const stems = p.stems
+    .map((stem) => ({ digest: stemDigestBytes(stem.digest), blobId: stem.blobId }))
+    .sort((a, b) => compareBytes(a.digest, b.digest));
+  for (let index = 1; index < stems.length; index += 1) {
+    if (compareBytes(stems[index - 1]!.digest, stems[index]!.digest) === 0) {
+      throw new Error(`duplicate stem digest ${toHex(stems[index]!.digest)}`);
+    }
+  }
+  return (tx) => {
+    const pkg = p.recordingEngineSessionPackageId;
+    const sessionBlob = unencryptedWalrusBlob(tx, p.oriPackageId, p.sessionBlobId);
+    const stemValues = stems.map((stem) => tx.add(engineSession.newStem({
+      package: pkg,
+      arguments: [
+        tx.pure.vector("u8", Array.from(stem.digest)),
+        unencryptedWalrusBlob(tx, p.oriPackageId, stem.blobId),
+      ],
+    })));
+    const stemVector = tx.makeMoveVec({
+      type: `${pkg}::recording_engine_session::Stem`,
+      elements: stemValues,
+    });
+    const session = tx.add(engineSession._new({
+      package: pkg,
+      arguments: [sessionBlob, stemVector],
+    }));
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${pkg}::recording_engine_session::set_engine_session`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId), session],
+      adminCapIndex: 1,
+    });
+  };
+}
+
+export type UnsetRecordingEngineSessionParams = Omit<
+  SetRecordingEngineSessionParams,
+  "oriPackageId" | "sessionBlobId" | "stems"
+>;
+
+/** Removes the Recording's Miso Engine session reference, if present. */
+export function unsetRecordingEngineSession(p: UnsetRecordingEngineSessionParams): TxThunk {
+  return (tx) => {
+    invokeWithAdminCap(tx, p.authority, {
+      target: `${p.recordingEngineSessionPackageId}::recording_engine_session::unset_engine_session`,
+      typeArguments: [p.recordingShareType, p.compositionShareType],
+      arguments: [object(tx, p.recordingId)],
+      adminCapIndex: 1,
+    });
+  };
+}
+
 /** Removes the Recording's streaming-transcode reference, if present. */
 export function unsetRecordingStreamingTranscode(
   p: UnsetRecordingStreamingTranscodeParams,
@@ -144,32 +241,95 @@ export function unsetRecordingStreamingTranscode(
   };
 }
 
+// ── Engine-session reads ─────────────────────────────────────────────────────
+
+/** A Recording's attached engine session, ids as decimal `u256` strings. */
+export interface RecordingEngineSessionView {
+  /** Unencrypted Walrus blob holding the canonical Session V1 JSON. */
+  readonly sessionBlobId: string;
+  /** Sorted by digest, as stored. `digest` is 64 lowercase hex chars. */
+  readonly stems: readonly { readonly digest: string; readonly blobId: string }[];
+}
+
+const EngineSessionField = bcs.struct("Field", {
+  id: bcs.Address,
+  name: engineSession.ExtensionKey,
+  value: engineSession.EngineSession,
+});
+const ENGINE_SESSION_KEY_BYTES = engineSession.ExtensionKey.serialize([false]).toBytes();
+
+/** Parse an engine-session dynamic field's BCS content. */
+export function parseRecordingEngineSessionContent(content: Uint8Array): RecordingEngineSessionView {
+  const { value } = EngineSessionField.parse(content);
+  if (value.data.confidentiality.$kind !== "Unencrypted") {
+    throw new Error("Recording engine session is unexpectedly encrypted");
+  }
+  return {
+    sessionBlobId: String(value.data.blob_id),
+    stems: value.stems.map((stem) => {
+      if (stem.data.confidentiality.$kind !== "Unencrypted") {
+        throw new Error("Recording engine session stem is unexpectedly encrypted");
+      }
+      return { digest: toHex(Uint8Array.from(stem.digest)), blobId: String(stem.data.blob_id) };
+    }),
+  };
+}
+
+/** Deterministic dynamic-field id for a Recording's engine session. */
+export function recordingEngineSessionFieldId(
+  recordingId: string,
+  recordingEngineSessionPackageId: string,
+): string {
+  return deriveDynamicFieldID(
+    recordingId,
+    `${recordingEngineSessionPackageId}::recording_engine_session::ExtensionKey`,
+    ENGINE_SESSION_KEY_BYTES,
+  );
+}
+
+/** Read one Recording's engine session, or null when none is attached. */
+export async function getRecordingEngineSession(
+  client: ClientWithCoreApi,
+  recordingId: string,
+  recordingEngineSessionPackageId: string,
+): Promise<RecordingEngineSessionView | null> {
+  const fieldId = recordingEngineSessionFieldId(recordingId, recordingEngineSessionPackageId);
+  const { objects } = await client.core.getObjects({
+    objectIds: [fieldId],
+    include: { content: true },
+  });
+  const field = objects[0];
+  if (!field) throw new Error("Recording engine-session read returned no result");
+  if (field instanceof Error) {
+    if (isNotFound(field)) return null;
+    throw field;
+  }
+  if (!field.content) throw new Error("Recording engine-session field is missing BCS content");
+  return parseRecordingEngineSessionContent(field.content);
+}
+
 // ── Master-reference reads ───────────────────────────────────────────────────
 
-// recording_master_reference stores the ori::WalrusData value inline in a
+// recording_master_reference stores the ori::data::WalrusBlob value inline in a
 // dynamic field on the Recording. Its empty ExtensionKey serializes to one false
 // byte, so the field object id can be derived without listing the Recording's
 // dynamic fields.
 const MasterReferenceField = bcs.struct("Field", {
   id: bcs.Address,
   name: masterReference.ExtensionKey,
-  value: walrusData.WalrusData,
+  value: walrusData.WalrusBlob,
 });
 const MASTER_REFERENCE_KEY_BYTES = masterReference.ExtensionKey.serialize([
   false,
 ]).toBytes();
 
-/** Parse an attached master reference's standalone Walrus blob id. */
-export function parseRecordingMasterReferenceContent(
-  content: Uint8Array,
-): string | null {
-  const reference = MasterReferenceField.parse(content).value as
-    | { $kind: "Blob"; Blob: [string | number | bigint, unknown] }
-    | {
-        $kind: "QuiltPatch";
-        QuiltPatch: [string | number | bigint, number, number, number];
-      };
-  return reference.$kind === "Blob" ? String(reference.Blob[0]) : null;
+/**
+ * Parse an attached master reference's standalone Walrus blob id (decimal
+ * `u256`). Encrypted masters are returned as-is: the reference is the same
+ * either way, and access control belongs to the caller.
+ */
+export function parseRecordingMasterReferenceContent(content: Uint8Array): string {
+  return String(MasterReferenceField.parse(content).value.blob_id);
 }
 
 /** Deterministic dynamic-field id for a Recording's master reference. */
@@ -231,8 +391,7 @@ export async function getRecordingMasterReferencesByIds(
     const target = targets[index];
     if (!target || object instanceof Error || !object.content) return;
     try {
-      const blobId = parseRecordingMasterReferenceContent(object.content);
-      if (blobId) out[target.recordingId] = blobId;
+      out[target.recordingId] = parseRecordingMasterReferenceContent(object.content);
     } catch {
       // Extension metadata is soft: retain valid tracks when one field is stale.
     }

package/src/walrus-ids.ts

@@ -0,0 +1,102 @@
+// Copyright (c) Miso Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Walrus blob id conversions.
+ *
+ * On chain a blob id is a `u256` (BCS little-endian). Off chain it is the
+ * unpadded base64url encoding of those same 32 little-endian bytes, which is
+ * also its key in a `miso-sources` staging bucket and its path on an
+ * aggregator. Both directions here are canonical: a value that does not
+ * round-trip byte for byte is rejected.
+ */
+
+const ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+/** Parse a `bigint` or decimal string as an exact `u256`. */
+export function walrusU256(label: string, value: bigint | string): bigint {
+  let parsed: bigint;
+  try {
+    parsed = typeof value === "bigint" ? value : BigInt(value);
+  } catch {
+    throw new Error(`${label} must be an exact u256 integer`);
+  }
+  if (parsed < 0n || parsed >= 1n << 256n) {
+    throw new Error(`${label} is outside u256 range`);
+  }
+  return parsed;
+}
+
+/** The base64url Walrus blob id for an on-chain `u256` blob id. */
+export function walrusBlobIdFromU256(value: bigint | string): string {
+  let remaining = walrusU256("Walrus blob id", value);
+  const bytes = new Uint8Array(32);
+  for (let index = 0; index < 32; index += 1) {
+    bytes[index] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return bytesToBase64Url(bytes);
+}
+
+/** The on-chain `u256` for a base64url Walrus blob id (43 characters). */
+export function walrusBlobIdToU256(blobId: string): bigint {
+  const bytes = base64UrlToBytes(blobId);
+  if (bytes.length !== 32) {
+    throw new Error("Walrus blob id must decode to exactly 32 bytes");
+  }
+  let value = 0n;
+  for (let index = 31; index >= 0; index -= 1) {
+    value = (value << 8n) | BigInt(bytes[index]!);
+  }
+  return value;
+}
+
+/** Unpadded base64url. */
+export function bytesToBase64Url(bytes: Uint8Array): string {
+  let output = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const a = bytes[index] ?? 0;
+    const b = bytes[index + 1] ?? 0;
+    const c = bytes[index + 2] ?? 0;
+    output += ALPHABET[a >>> 2];
+    output += ALPHABET[((a & 3) << 4) | (b >>> 4)];
+    if (index + 1 < bytes.length) {
+      output += ALPHABET[((b & 15) << 2) | (c >>> 6)];
+    }
+    if (index + 2 < bytes.length) output += ALPHABET[c & 63];
+  }
+  return output;
+}
+
+/** Strict inverse of {@link bytesToBase64Url}: no padding, no stray bits. */
+export function base64UrlToBytes(value: string): Uint8Array {
+  if (
+    typeof value !== "string" ||
+    value.length % 4 === 1 ||
+    value.includes("=") ||
+    !/^[A-Za-z0-9_-]*$/.test(value)
+  ) {
+    throw new Error("invalid canonical base64url");
+  }
+  const bytes = new Uint8Array(Math.floor((value.length * 6) / 8));
+  let accumulator = 0;
+  let bits = 0;
+  let outputIndex = 0;
+  for (const character of value) {
+    const digit = ALPHABET.indexOf(character);
+    if (digit < 0) throw new Error("invalid canonical base64url");
+    accumulator = (accumulator << 6) | digit;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes[outputIndex] = (accumulator >>> bits) & 0xff;
+      outputIndex += 1;
+      accumulator &= (1 << bits) - 1;
+    }
+  }
+  if (bytesToBase64Url(bytes) !== value) {
+    throw new Error("invalid canonical base64url padding bits");
+  }
+  return bytes;
+}