@effect-uai/google 0.2.0 → 0.4.0

package/src/LyriaGenerator.ts

@@ -0,0 +1,394 @@
+import {
+  Array as Arr,
+  Context,
+  Effect,
+  Encoding,
+  Layer,
+  Match,
+  Option,
+  Redacted,
+  Result,
+  Schema,
+  Stream,
+} from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import type { AudioChunk, AudioFormat } from "@effect-uai/core/Audio"
+import type {
+  CommonGenerateMusicRequest,
+  CommonStreamGenerateMusicRequest,
+  MusicResult,
+  MusicSessionInput,
+  WeightedPrompt,
+} from "@effect-uai/core/Music"
+import { MusicGenerator, type MusicGeneratorService } from "@effect-uai/core/MusicGenerator"
+import type { LyriaModel } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Lyria-typed generate request. Narrows `model` to `LyriaModel`. The
+ * Lyria sync API (`generateContent`) accepts only `audio/mp3` and
+ * `audio/wav` output; `bpm`, `scale`, `instrumental` etc. on the
+ * `CommonGenerateMusicRequest` are flattened into the prompt text
+ * because the public API does not expose them as structured fields.
+ */
+export type LyriaGenerateRequest = Omit<CommonGenerateMusicRequest, "model"> & {
+  readonly model: LyriaModel
+}
+
+export type LyriaGeneratorService = {
+  readonly generate: (request: LyriaGenerateRequest) => Effect.Effect<MusicResult, AiError.AiError>
+  readonly streamGeneration: (
+    request: LyriaGenerateRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError>
+  readonly streamGenerationFrom: <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+    request: CommonStreamGenerateMusicRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R>
+}
+
+export class LyriaGenerator extends Context.Service<LyriaGenerator, LyriaGeneratorService>()(
+  "@betalyra/effect-uai/providers/google/LyriaGenerator",
+) {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Codec — request → prompt text + response_format
+// ---------------------------------------------------------------------------
+
+export type LyriaResponseMimeType = "audio/mp3" | "audio/wav"
+
+export const containerToMimeType: (
+  container: AudioFormat["container"],
+) => Effect.Effect<LyriaResponseMimeType, AiError.AiError> = Match.type<
+  AudioFormat["container"]
+>().pipe(
+  Match.when("mp3", () => Effect.succeed<LyriaResponseMimeType>("audio/mp3")),
+  Match.when("wav", () => Effect.succeed<LyriaResponseMimeType>("audio/wav")),
+  Match.whenOr("ogg", "opus", "flac", "aac", "webm", "raw", (c) =>
+    Effect.fail(
+      new AiError.Unsupported({
+        provider: "lyria",
+        capability: "outputFormat",
+        reason: `Lyria 3 only produces audio/mp3 or audio/wav; ${c} is not available. Use container: "mp3" or "wav".`,
+      }),
+    ),
+  ),
+  Match.exhaustive,
+)
+
+/**
+ * Is this a Lyria 3 Clip model variant? Clip is fixed at 30 s MP3 — it
+ * does not accept a `responseFormat` on `generationConfig` (the live
+ * API rejects unknown fields, despite what the docs imply). Pro
+ * accepts the documented `responseFormat` knob.
+ */
+const isClipModel = (model: string): boolean => model.includes("clip")
+
+export const realizedFormat: (mime: LyriaResponseMimeType) => AudioFormat =
+  Match.type<LyriaResponseMimeType>().pipe(
+    Match.when(
+      "audio/mp3",
+      (): AudioFormat => ({ container: "mp3", encoding: "mp3", sampleRate: 44100, channels: 2 }),
+    ),
+    Match.when(
+      "audio/wav",
+      (): AudioFormat => ({
+        container: "wav",
+        encoding: "pcm_s16le",
+        sampleRate: 44100,
+        channels: 2,
+      }),
+    ),
+    Match.exhaustive,
+  )
+
+/**
+ * Collapse `prompts | WeightedPrompt[]` into a single prompt string and
+ * splice in non-structural hints (`lyrics`, `bpm`, `scale`,
+ * `instrumental`, `durationSeconds`). The Lyria 3 sync API only takes
+ * one text part — every condition lives inline.
+ */
+export const buildPrompt = (request: CommonGenerateMusicRequest): string => {
+  const promptText = Match.value(request.prompts).pipe(
+    Match.when(Match.string, (s) => s),
+    Match.orElse((ws: ReadonlyArray<WeightedPrompt>) =>
+      Arr.map(ws, (w) =>
+        w.weight !== undefined && w.weight !== 1 ? `${w.text} (weight ${w.weight})` : w.text,
+      ).join(". "),
+    ),
+  )
+  const hints = Arr.getSomes([
+    request.instrumental === true ? Option.some("Instrumental only — no vocals.") : Option.none(),
+    request.bpm !== undefined ? Option.some(`BPM: ${request.bpm}.`) : Option.none(),
+    request.scale !== undefined ? Option.some(`Key/scale: ${request.scale}.`) : Option.none(),
+    request.durationSeconds !== undefined
+      ? Option.some(`Target duration: ${request.durationSeconds}s.`)
+      : Option.none(),
+  ])
+  const lyricsBlock =
+    request.lyrics !== undefined && request.instrumental !== true
+      ? `\n\nLyrics:\n${request.lyrics}`
+      : ""
+  return [promptText, ...hints].join(" ") + lyricsBlock
+}
+
+// ---------------------------------------------------------------------------
+// Wire response schema — just enough to find audio + optional lyrics text
+// ---------------------------------------------------------------------------
+
+const InlineData = Schema.Struct({
+  mimeType: Schema.optional(Schema.String),
+  data: Schema.String,
+})
+
+const Part = Schema.Struct({
+  text: Schema.optional(Schema.String),
+  inlineData: Schema.optional(InlineData),
+})
+
+const Content = Schema.Struct({
+  parts: Schema.optional(Schema.Array(Part)),
+})
+
+const Candidate = Schema.Struct({
+  content: Schema.optional(Content),
+})
+
+const Wire = Schema.Struct({
+  candidates: Schema.optional(Schema.Array(Candidate)),
+})
+
+const decodeWire = Schema.decodeUnknownEffect(Wire)
+
+// ---------------------------------------------------------------------------
+// HTTP plumbing
+// ---------------------------------------------------------------------------
+
+const baseUrl = (cfg: Config): string =>
+  cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
+
+const transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "lyria", raw: cause })
+
+const httpStatusError: (status: number, body: string) => AiError.AiError = (status, body) =>
+  Match.value(status).pipe(
+    Match.when(
+      429,
+      (): AiError.AiError => new AiError.RateLimited({ provider: "lyria", raw: body }),
+    ),
+    Match.whenOr(
+      408,
+      504,
+      (): AiError.AiError => new AiError.Timeout({ provider: "lyria", raw: body }),
+    ),
+    Match.when(
+      401,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "auth", raw: body }),
+    ),
+    Match.when(
+      403,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "permission", raw: body }),
+    ),
+    Match.when(
+      402,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "billing", raw: body }),
+    ),
+    Match.when(
+      (n) => n >= 500,
+      (n): AiError.AiError => new AiError.Unavailable({ provider: "lyria", status: n, raw: body }),
+    ),
+    Match.orElse(
+      (): AiError.AiError => new AiError.InvalidRequest({ provider: "lyria", raw: body }),
+    ),
+  )
+
+const decodeBase64ToBytes = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
+  Result.match(Encoding.decodeBase64(b64), {
+    onSuccess: Effect.succeed,
+    onFailure: (cause) =>
+      Effect.fail(new AiError.InvalidRequest({ provider: "lyria", param: "audio", raw: cause })),
+  })
+
+/**
+ * Find the first inline-data audio part and the concatenated text parts
+ * from a Wire response.
+ */
+const extractParts = (
+  wire: typeof Wire.Type,
+): { readonly inline?: typeof InlineData.Type; readonly text?: string } => {
+  const allParts = (wire.candidates ?? []).flatMap((c) => c.content?.parts ?? [])
+  const inline = allParts.find((p) => p.inlineData !== undefined)?.inlineData
+  const textParts = allParts.flatMap((p) => (p.text !== undefined ? [p.text] : []))
+  const text = textParts.length === 0 ? undefined : textParts.join("\n")
+  return {
+    ...(inline !== undefined && { inline }),
+    ...(text !== undefined && { text }),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Service implementation
+// ---------------------------------------------------------------------------
+
+const generateImpl =
+  (cfg: Config) =>
+  (
+    request: LyriaGenerateRequest,
+  ): Effect.Effect<MusicResult, AiError.AiError, HttpClient.HttpClient> =>
+    Effect.gen(function* () {
+      const client = yield* HttpClient.HttpClient
+      const requestedContainer = (request.outputFormat?.container ??
+        "mp3") satisfies AudioFormat["container"]
+      const mimeType = yield* containerToMimeType(requestedContainer)
+      // Clip is fixed 30 s mp3 — reject wav up front rather than sending
+      // a `responseFormat` that the live API ignores or rejects.
+      if (isClipModel(request.model) && mimeType === "audio/wav") {
+        return yield* Effect.fail(
+          new AiError.Unsupported({
+            provider: "lyria",
+            capability: "outputFormat",
+            reason: `lyria-3-clip-preview is fixed at audio/mp3. Use lyria-3-pro-preview for audio/wav output.`,
+          }),
+        )
+      }
+      const promptText = buildPrompt(request)
+      const body = isClipModel(request.model)
+        ? { contents: [{ parts: [{ text: promptText }] }] }
+        : {
+            contents: [{ parts: [{ text: promptText }] }],
+            generationConfig: {
+              responseModalities: ["AUDIO", "TEXT"],
+              responseFormat: { audio: { mimeType } },
+            },
+          }
+      const httpRequest = HttpClientRequest.post(
+        `${baseUrl(cfg)}/models/${request.model}:generateContent`,
+      ).pipe(
+        HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)),
+        HttpClientRequest.bodyJsonUnsafe(body),
+      )
+      const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+      if (response.status >= 400) {
+        const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+        return yield* Effect.fail(httpStatusError(response.status, text))
+      }
+      const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+      const wire = yield* decodeWire(json).pipe(
+        Effect.mapError(
+          (cause): AiError.AiError =>
+            new AiError.GenerationFailed({ provider: "lyria", raw: cause }),
+        ),
+      )
+      const { inline, text } = extractParts(wire)
+      if (inline === undefined) {
+        // No audio came back. Most common cause: Lyria filtered the prompt
+        // (named-artist references, copyrighted lyrics, etc.). Surface the
+        // full response body — text parts, finish reasons, prompt-feedback
+        // blocks — so the caller can see why.
+        return yield* Effect.fail(
+          new AiError.GenerationFailed({
+            provider: "lyria",
+            raw: {
+              message: "Lyria response had no inlineData audio part.",
+              hint: "Likely a prompt-filter rejection. Lyria filters references to real artists / copyrighted song lyrics. Rephrase with descriptive style language instead of artist names.",
+              textParts: text,
+              response: json,
+            },
+          }),
+        )
+      }
+      const bytes = yield* decodeBase64ToBytes(inline.data)
+      return {
+        format: realizedFormat(mimeType),
+        bytes,
+        ...(text !== undefined && { lyrics: text }),
+        watermark: { kind: "synthid" },
+      } satisfies MusicResult
+    })
+
+const streamGenerationImpl =
+  (cfg: Config) =>
+  (
+    request: LyriaGenerateRequest,
+  ): Stream.Stream<AudioChunk, AiError.AiError, HttpClient.HttpClient> =>
+    Stream.unwrap(
+      Effect.map(generateImpl(cfg)(request), (result) =>
+        Stream.succeed<AudioChunk>({ bytes: result.bytes }),
+      ),
+    )
+
+/**
+ * Lyria 3 sync has no bidirectional session at the wire level — that's
+ * Lyria RealTime (Phase 1b, separate Layer). The provider Layer here
+ * also does NOT register `MusicInteractiveSession`, so callers using
+ * `MusicGenerator.streamGenerationFrom` against only this Layer get a
+ * compile-time error before this runtime fallback ever fires.
+ */
+const streamGenerationFromUnsupported = <E, R>(
+  _input: Stream.Stream<MusicSessionInput, E, R>,
+  _request: CommonStreamGenerateMusicRequest,
+): Stream.Stream<AudioChunk, AiError.AiError | E, R> => {
+  const fail: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+    new AiError.Unsupported({
+      provider: "lyria",
+      capability: "streamGenerationFrom",
+      reason:
+        "Lyria 3 sync does not support bidirectional sessions. Use the Lyria RealTime Layer (WebSocket BidiGenerateMusic) for interactive mid-session prompts.",
+    }),
+  )
+  return fail
+}
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+export const make = (
+  cfg: Config,
+): Effect.Effect<LyriaGeneratorService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+    generate: (request) =>
+      generateImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    streamGeneration: (request) =>
+      streamGenerationImpl(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client)),
+    streamGenerationFrom: streamGenerationFromUnsupported,
+  }))
+
+/**
+ * Layer that registers both the provider-specific `LyriaGenerator` tag
+ * and the generic `MusicGenerator` tag.
+ *
+ * Does NOT register the `MusicInteractiveSession` capability marker —
+ * Lyria 3 sync has no bidirectional session at the wire level. Code
+ * calling `MusicGenerator.streamGenerationFrom` will fail to typecheck
+ * against this Layer alone, which is the intended UX.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<LyriaGenerator | MusicGenerator, never, HttpClient.HttpClient> =>
+  Layer.merge(
+    Layer.effect(LyriaGenerator, make(cfg)),
+    Layer.effect(
+      MusicGenerator,
+      Effect.map(
+        make(cfg),
+        (s): MusicGeneratorService => ({
+          generate: (req: CommonGenerateMusicRequest) => s.generate(req as LyriaGenerateRequest),
+          streamGeneration: (req: CommonStreamGenerateMusicRequest) =>
+            s.streamGeneration(req as LyriaGenerateRequest),
+          streamGenerationFrom: s.streamGenerationFrom,
+        }),
+      ),
+    ),
+  )

package/src/codec.ts

@@ -1,6 +1,5 @@
-import { Array as Arr, Match, Option, Result, Schema, pipe } from "effect"
-import type { ContentBlock, Item, Message } from "@effect-uai/core/Items"
-import { matchType } from "@effect-uai/core/Match"
+import { Array as Arr, Encoding, Match, Option, Result, Schema, pipe } from "effect"
+import type { ContentBlock, InputImage, Item, Message } from "@effect-uai/core/Items"
 import type { Turn } from "@effect-uai/core/Turn"
 
 // ---------------------------------------------------------------------------
@@ -53,20 +52,20 @@ type RequestPart =
   | { readonly text: string }
   | { readonly inlineData: { readonly mimeType: string; readonly data: string } }
 
-interface RequestContent {
+type RequestContent = {
   readonly role: "user" | "model"
   readonly parts: ReadonlyArray<RequestPart>
 }
 
-interface RequestSystemInstruction {
+type RequestSystemInstruction = {
   readonly parts: ReadonlyArray<{ readonly text: string }>
 }
 
-export interface ThinkingConfig {
+export type ThinkingConfig = {
   readonly thinkingBudget: number
 }
 
-export interface GenerationConfig {
+export type GenerationConfig = {
   readonly temperature?: number
   readonly maxOutputTokens?: number
   readonly topP?: number
@@ -77,47 +76,55 @@ export interface GenerationConfig {
   readonly responseJsonSchema?: Record<string, unknown>
 }
 
-export interface RequestBody {
+export type RequestBody = {
   readonly contents: ReadonlyArray<RequestContent>
   readonly systemInstruction?: RequestSystemInstruction
   readonly generationConfig?: GenerationConfig
 }
 
 const blockText = Match.type<ContentBlock>().pipe(
-  matchType("input_text", (b) => b.text),
-  matchType("input_image", () => ""),
-  matchType("output_text", (b) => b.text),
-  matchType("refusal", (b) => b.text),
-  Match.exhaustive,
+  Match.discriminatorsExhaustive("type")({
+    input_text: (b) => b.text,
+    input_image: () => "",
+    output_text: (b) => b.text,
+    refusal: (b) => b.text,
+  }),
 )
 
 const messageText = (message: Message): string => message.content.map(blockText).join("")
 
-const blockToParts = Match.type<ContentBlock>().pipe(
-  matchType(
-    "input_text",
-    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
-  ),
-  matchType(
-    "input_image",
-    (b): ReadonlyArray<RequestPart> =>
-      // Gemini's `fileData` form expects a pre-uploaded Files API URI, not an
-      // arbitrary HTTPS URL - we'd need to fetch + re-upload to support that.
-      // Skip URL-form images for now; document as a follow-up.
-      b.source._tag === "base64"
-        ? [{ inlineData: { mimeType: b.source.media_type, data: b.source.data } }]
-        : [],
+/**
+ * Gemini's `inlineData` form expects a base64 payload. URL-form images
+ * would need to go through Gemini's Files API (upload then `fileData`
+ * with the returned URI); pre-uploading isn't free, so we skip those for
+ * now and document as a follow-up.
+ */
+const imageSourceToParts = Match.type<InputImage["source"]>().pipe(
+  Match.tag("url", (): ReadonlyArray<RequestPart> => []),
+  Match.tag(
+    "base64",
+    (s): ReadonlyArray<RequestPart> => [{ inlineData: { mimeType: s.mimeType, data: s.base64 } }],
   ),
-  matchType(
-    "output_text",
-    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
+  Match.tag(
+    "bytes",
+    (s): ReadonlyArray<RequestPart> => [
+      { inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) } },
+    ],
   ),
-  // Refusals are assistant-side content; they don't round-trip into Gemini's
-  // request body as parts. Skip.
-  matchType("refusal", (): ReadonlyArray<RequestPart> => []),
   Match.exhaustive,
 )
 
+const blockToParts = Match.type<ContentBlock>().pipe(
+  Match.discriminatorsExhaustive("type")({
+    input_text: (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
+    input_image: (b): ReadonlyArray<RequestPart> => imageSourceToParts(b.source),
+    output_text: (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
+    // Refusals are assistant-side content; they don't round-trip into Gemini's
+    // request body as parts. Skip.
+    refusal: (): ReadonlyArray<RequestPart> => [],
+  }),
+)
+
 const messageToContent = (message: Message): Result.Result<RequestContent, void> => {
   const parts = pipe(message.content, Arr.flatMap(blockToParts))
   if (parts.length === 0) return Result.failVoid
@@ -173,7 +180,7 @@ const finishReasonToStop = (reason: Option.Option<string>): Turn["stop_reason"]
     onSome: (r) => (r === "MAX_TOKENS" ? ("max_tokens" as const) : ("stop" as const)),
   })
 
-export interface Accumulator {
+export type Accumulator = {
   readonly text: string
   readonly reasoning: string
   readonly finishReason: Option.Option<string>
@@ -202,7 +209,7 @@ export type ChunkPart =
   | { readonly kind: "text"; readonly text: string }
   | { readonly kind: "reasoning"; readonly text: string }
 
-export interface ChunkResult {
+export type ChunkResult = {
   readonly accumulator: Accumulator
   readonly parts: ReadonlyArray<ChunkPart>
   readonly finished: boolean

package/src/geminiSpeechCodec.test.ts

@@ -0,0 +1,56 @@
+import { Effect, Encoding } from "effect"
+import { describe, expect, it } from "vitest"
+import type { AudioSource } from "@effect-uai/core/Audio"
+import { audioSourceToInlineData, wrapPcmAsWav } from "./geminiSpeechCodec.js"
+
+describe("audioSourceToInlineData", () => {
+  it("encodes a `bytes` source to base64 with its MIME type", async () => {
+    const original = new Uint8Array([0xde, 0xad, 0xbe, 0xef])
+    const source: AudioSource = { _tag: "bytes", bytes: original, mimeType: "audio/wav" }
+    const inline = await Effect.runPromise(audioSourceToInlineData(source))
+    expect(inline.mimeType).toBe("audio/wav")
+    expect(inline.data).toBe(Encoding.encodeBase64(original))
+  })
+
+  it("passes a `base64` source through unchanged", async () => {
+    const b64 = Encoding.encodeBase64(new Uint8Array([1, 2, 3]))
+    const source: AudioSource = { _tag: "base64", base64: b64, mimeType: "audio/mp3" }
+    const inline = await Effect.runPromise(audioSourceToInlineData(source))
+    expect(inline.mimeType).toBe("audio/mp3")
+    expect(inline.data).toBe(b64)
+  })
+
+  it("fails InvalidRequest for a URL source", async () => {
+    const source: AudioSource = { _tag: "url", url: "https://x/y.mp3", mimeType: "audio/mp3" }
+    const exit = await Effect.runPromiseExit(audioSourceToInlineData(source))
+    expect(exit._tag).toBe("Failure")
+    if (exit._tag === "Failure") {
+      expect(JSON.stringify(exit.cause)).toContain("InvalidRequest")
+      expect(JSON.stringify(exit.cause)).toContain("Files API")
+    }
+  })
+})
+
+describe("wrapPcmAsWav", () => {
+  it("produces a 44-byte RIFF/WAVE header for 16-bit mono PCM at 24 kHz", () => {
+    const pcm = new Uint8Array([0x00, 0x01, 0x00, 0x02])
+    const wav = wrapPcmAsWav(pcm, 24000, 1, 16)
+    expect(wav.length).toBe(44 + pcm.length)
+    const ascii = (start: number, len: number) =>
+      String.fromCharCode(...Array.from(wav.slice(start, start + len)))
+    expect(ascii(0, 4)).toBe("RIFF")
+    expect(ascii(8, 4)).toBe("WAVE")
+    expect(ascii(12, 4)).toBe("fmt ")
+    expect(ascii(36, 4)).toBe("data")
+    // RIFF chunk size = total - 8
+    const view = new DataView(wav.buffer)
+    expect(view.getUint32(4, true)).toBe(wav.length - 8)
+    expect(view.getUint16(20, true)).toBe(1) // PCM
+    expect(view.getUint16(22, true)).toBe(1) // mono
+    expect(view.getUint32(24, true)).toBe(24000) // sample rate
+    expect(view.getUint16(34, true)).toBe(16) // bits per sample
+    expect(view.getUint32(40, true)).toBe(pcm.length) // data size
+    // Payload preserved
+    expect(Array.from(wav.slice(44))).toEqual(Array.from(pcm))
+  })
+})