sakuga 0.0.1

package/dist/index.js

@@ -0,0 +1,237 @@
+import {
+  CanvasContextUnavailable,
+  DEFAULT_BLOCK_DURATION,
+  DEFAULT_FPS,
+  DEFAULT_HEIGHT,
+  DEFAULT_THEME,
+  DEFAULT_TRANSITION_DURATION_MS,
+  DEFAULT_WIDTH,
+  MissingCanvasFactory,
+  NoEncodableVideoCodec,
+  OutputBufferMissing,
+  WebCodecsUnavailable,
+  blendColors,
+  buildScene,
+  buildTransitionDiff,
+  buildTransitionTokens,
+  diffLayoutTokens,
+  easeInOutCubic,
+  parseMarkdownCodeBlocks,
+  renderFrame,
+  resolveTheme
+} from "./shared/chunk-ks7faw1s.js";
+// src/lib/render-api.ts
+import { Effect as Effect2 } from "effect";
+
+// src/lib/browser.ts
+import { Effect, Ref, Stream } from "effect";
+import {
+  BufferTarget,
+  Mp4OutputFormat,
+  Output,
+  QUALITY_HIGH,
+  VideoSample,
+  VideoSampleSource,
+  WebMOutputFormat,
+  getFirstEncodableVideoCodec
+} from "mediabunny";
+var getCanvasContext = (canvas) => Effect.gen(function* () {
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return yield* Effect.fail(new CanvasContextUnavailable({ reason: "Unable to acquire 2D canvas context." }));
+  }
+  return context;
+});
+var ensureWebCodecs = () => Effect.gen(function* () {
+  if (typeof VideoEncoder === "undefined" || typeof VideoFrame === "undefined") {
+    return yield* Effect.fail(new WebCodecsUnavailable({
+      reason: "WebCodecs VideoEncoder is not available in this browser."
+    }));
+  }
+});
+var computeFrameCounts = (transitionDurationMs, fps) => {
+  const frameDuration = 1 / fps;
+  const blockFrames = Math.max(1, Math.round(DEFAULT_BLOCK_DURATION * fps));
+  const transitionFrames = Math.max(1, Math.round(transitionDurationMs / 1000 * fps));
+  return {
+    blockFrames,
+    frameDuration,
+    transitionFrames
+  };
+};
+var makeOutput = (format) => Effect.sync(() => {
+  const resolvedFormat = format === "webm" ? new WebMOutputFormat : new Mp4OutputFormat;
+  const target = new BufferTarget;
+  const outputInstance = new Output({
+    format: resolvedFormat,
+    target
+  });
+  return {
+    mimeType: resolvedFormat.mimeType,
+    output: outputInstance,
+    target
+  };
+});
+var makeVideoSource = (codec) => Effect.sync(() => new VideoSampleSource({
+  bitrate: QUALITY_HIGH,
+  codec
+}));
+var renderAndWriteFrame = (context, videoSource, frameDuration, frameIndexRef, width, height) => (frame) => Effect.gen(function* () {
+  const frameIndex = yield* Ref.get(frameIndexRef);
+  renderFrame(context, width, height, frame);
+  const imageData = context.getImageData(0, 0, width, height);
+  const sample = new VideoSample(imageData.data, {
+    codedHeight: height,
+    codedWidth: width,
+    duration: frameDuration,
+    format: "RGBA",
+    timestamp: frameIndex * frameDuration
+  });
+  yield* Effect.tryPromise({
+    catch: (error) => error instanceof Error ? error : new Error(String(error)),
+    try: () => videoSource.add(sample)
+  });
+  sample.close();
+  yield* Ref.set(frameIndexRef, frameIndex + 1);
+});
+var buildSceneFrames = (scene, blockFrames) => Stream.range(1, blockFrames).pipe(Stream.map(() => ({
+  background: scene.background,
+  kind: "scene",
+  opacity: 1,
+  positionX: scene.blockX,
+  positionY: scene.blockY,
+  scene
+})));
+var buildTransitionFrames = (scene, nextScene, transitionFrames) => {
+  const diff = buildTransitionDiff(scene, nextScene);
+  return Stream.range(1, transitionFrames).pipe(Stream.map((index) => {
+    const rawProgress = index / transitionFrames;
+    const progress = easeInOutCubic(rawProgress);
+    const blendedBackground = blendColors(scene.background, nextScene.background, progress);
+    const tokens = buildTransitionTokens(diff, progress);
+    return {
+      background: blendedBackground,
+      kind: "transition",
+      tokens
+    };
+  }));
+};
+var buildFramesStream = (scenes, blockFrames, transitionFrames) => Stream.fromIterable(scenes).pipe(Stream.zipWithIndex, Stream.flatMap(([scene, index]) => {
+  const nextScene = scenes[index + 1];
+  const base = buildSceneFrames(scene, blockFrames);
+  return nextScene ? Stream.concat(base, buildTransitionFrames(scene, nextScene, transitionFrames)) : base;
+}));
+var resolveFormat = (format, height, width) => Effect.gen(function* () {
+  if (format !== "auto") {
+    return {
+      codec: format === "mp4" ? "avc" : "vp9",
+      container: format
+    };
+  }
+  const codec = yield* Effect.tryPromise({
+    catch: () => new NoEncodableVideoCodec({
+      reason: "No encodable video codec available in this browser."
+    }),
+    try: () => getFirstEncodableVideoCodec(["avc", "vp9", "vp8"], {
+      bitrate: QUALITY_HIGH,
+      height,
+      width
+    })
+  });
+  if (!codec) {
+    return yield* Effect.fail(new NoEncodableVideoCodec({
+      reason: "No encodable video codec available in this browser."
+    }));
+  }
+  return {
+    codec,
+    container: codec === "avc" ? "mp4" : "webm"
+  };
+});
+var resolveCanvas = (canvas, height, width, createCanvas) => Effect.gen(function* () {
+  if (canvas) {
+    const context2 = yield* getCanvasContext(canvas);
+    return {
+      canvas,
+      context: context2
+    };
+  }
+  if (!createCanvas) {
+    return yield* Effect.fail(new MissingCanvasFactory({
+      reason: "Browser canvas factory is required when no canvas is provided."
+    }));
+  }
+  const created = createCanvas(height, width);
+  const context = yield* getCanvasContext(created);
+  return {
+    canvas: created,
+    context
+  };
+});
+var renderVideoBrowser = (theme, codeBlocks, options = {}) => Effect.gen(function* () {
+  yield* ensureWebCodecs();
+  const width = options.width ?? DEFAULT_WIDTH;
+  const height = options.height ?? DEFAULT_HEIGHT;
+  const transitionDurationMs = options.transitionDurationMs ?? DEFAULT_TRANSITION_DURATION_MS;
+  const format = options.format ?? "auto";
+  const { context } = yield* resolveCanvas(options.canvas, height, width, options.createCanvas);
+  const resolved = yield* resolveFormat(format, height, width);
+  const outputInfo = yield* makeOutput(resolved.container);
+  const frameCounts = computeFrameCounts(transitionDurationMs, DEFAULT_FPS);
+  const frameIndexRef = yield* Ref.make(0);
+  const scenes = yield* Effect.forEach(codeBlocks, (codeBlock) => buildScene(context, codeBlock, theme, width, height), { concurrency: options.concurrency });
+  const videoSource = yield* makeVideoSource(resolved.codec);
+  return yield* Effect.scoped(Effect.gen(function* () {
+    yield* Effect.sync(() => {
+      outputInfo.output.addVideoTrack(videoSource, { frameRate: DEFAULT_FPS });
+    });
+    yield* Effect.tryPromise({
+      catch: (error) => error instanceof Error ? error : new Error(String(error)),
+      try: () => outputInfo.output.start()
+    });
+    const frameStream = buildFramesStream(scenes, frameCounts.blockFrames, frameCounts.transitionFrames);
+    yield* Stream.runForEach(frameStream, renderAndWriteFrame(context, videoSource, frameCounts.frameDuration, frameIndexRef, width, height));
+    yield* Effect.tryPromise({
+      catch: (error) => error instanceof Error ? error : new Error(String(error)),
+      try: () => outputInfo.output.finalize()
+    });
+    videoSource.close();
+    const buffer = outputInfo.target.buffer;
+    if (!buffer) {
+      return yield* Effect.fail(new OutputBufferMissing({
+        reason: "Output buffer missing after finalize."
+      }));
+    }
+    const output = {
+      data: new Uint8Array(buffer),
+      extension: resolved.container,
+      mimeType: outputInfo.mimeType
+    };
+    return output;
+  }));
+});
+
+// src/lib/render-api.ts
+var render = (options) => Effect2.runPromise(Effect2.gen(function* () {
+  const theme = options.theme ?? DEFAULT_THEME;
+  const resolvedTheme = yield* resolveTheme(theme);
+  const blocks = yield* parseMarkdownCodeBlocks(options.markdown);
+  const result = yield* renderVideoBrowser(resolvedTheme, blocks, {
+    canvas: options.canvas,
+    concurrency: options.concurrency,
+    createCanvas: options.createCanvas,
+    format: options.format,
+    height: options.height,
+    transitionDurationMs: options.transitionDurationMs,
+    width: options.width
+  });
+  return result;
+}));
+export {
+  render,
+  parseMarkdownCodeBlocks,
+  diffLayoutTokens
+};
+
+//# debugId=30C1AF8D08558A9464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/lib/render-api.ts", "src/lib/browser.ts"],
  "sourcesContent": [
    "import { Effect } from \"effect\"\nimport { renderVideoBrowser, type RenderVideoBrowserOptions } from \"./browser\"\nimport { DEFAULT_THEME } from \"./constants\"\nimport { parseMarkdownCodeBlocks } from \"./markdown\"\nimport { resolveTheme } from \"./theme\"\n\nexport type RenderOptions = RenderVideoBrowserOptions & {\n  markdown: string\n  theme?: string\n}\n\nexport type RenderResult =\n  ReturnType<typeof renderVideoBrowser> extends Effect.Effect<infer A, unknown> ? A : never\n\nexport const render = (options: RenderOptions) =>\n  Effect.runPromise(\n    Effect.gen(function* () {\n      const theme = options.theme ?? DEFAULT_THEME\n      const resolvedTheme = yield* resolveTheme(theme)\n      const blocks = yield* parseMarkdownCodeBlocks(options.markdown)\n\n      const result = yield* renderVideoBrowser(resolvedTheme, blocks, {\n        canvas: options.canvas,\n        concurrency: options.concurrency,\n        createCanvas: options.createCanvas,\n        format: options.format,\n        height: options.height,\n        transitionDurationMs: options.transitionDurationMs,\n        width: options.width,\n      })\n\n      return result\n    })\n  )\n",
    "import { Effect, Ref, Stream } from \"effect\"\nimport {\n  BufferTarget,\n  Mp4OutputFormat,\n  Output,\n  QUALITY_HIGH,\n  VideoSample,\n  VideoSampleSource,\n  WebMOutputFormat,\n  getFirstEncodableVideoCodec,\n} from \"mediabunny\"\nimport type { CanvasContext } from \"./context\"\nimport type { CodeBlock, RenderFrame, Scene } from \"./types\"\nimport { blendColors } from \"./color\"\nimport {\n  DEFAULT_BLOCK_DURATION,\n  DEFAULT_FPS,\n  DEFAULT_HEIGHT,\n  DEFAULT_TRANSITION_DURATION_MS,\n  DEFAULT_WIDTH,\n} from \"./constants\"\nimport {\n  CanvasContextUnavailable,\n  MissingCanvasFactory,\n  NoEncodableVideoCodec,\n  OutputBufferMissing,\n  WebCodecsUnavailable,\n} from \"./errors\"\nimport { renderFrame } from \"./render\"\nimport { buildScene } from \"./scene\"\nimport { buildTransitionDiff, buildTransitionTokens, easeInOutCubic } from \"./transition\"\n\nexport type BrowserFormat = \"mp4\" | \"webm\" | \"auto\"\n\nexport type CanvasLike = {\n  getContext: (type: \"2d\") => CanvasContext | null\n  height: number\n  width: number\n}\n\nexport type CanvasFactory = (height: number, width: number) => CanvasLike\n\nexport type BrowserOutput = {\n  data: Uint8Array\n  extension: \"mp4\" | \"webm\"\n  mimeType: string\n}\n\nexport type RenderVideoBrowserOptions = {\n  canvas?: CanvasLike\n  concurrency?: number\n  createCanvas?: CanvasFactory\n  format?: BrowserFormat\n  height?: number\n  transitionDurationMs?: number\n  width?: number\n}\n\nconst getCanvasContext = (canvas: CanvasLike) =>\n  Effect.gen(function* () {\n    const context = canvas.getContext(\"2d\")\n    if (!context) {\n      return yield* Effect.fail(\n        new CanvasContextUnavailable({ reason: \"Unable to acquire 2D canvas context.\" })\n      )\n    }\n\n    return context\n  })\n\nconst ensureWebCodecs = () =>\n  Effect.gen(function* () {\n    if (typeof VideoEncoder === \"undefined\" || typeof VideoFrame === \"undefined\") {\n      return yield* Effect.fail(\n        new WebCodecsUnavailable({\n          reason: \"WebCodecs VideoEncoder is not available in this browser.\",\n        })\n      )\n    }\n  })\n\nconst computeFrameCounts = (transitionDurationMs: number, fps: number) => {\n  const frameDuration = 1 / fps\n  const blockFrames = Math.max(1, Math.round(DEFAULT_BLOCK_DURATION * fps))\n  const transitionFrames = Math.max(1, Math.round((transitionDurationMs / 1000) * fps))\n\n  return {\n    blockFrames,\n    frameDuration,\n    transitionFrames,\n  }\n}\n\nconst makeOutput = (format: \"mp4\" | \"webm\") =>\n  Effect.sync(() => {\n    const resolvedFormat = format === \"webm\" ? new WebMOutputFormat() : new Mp4OutputFormat()\n    const target = new BufferTarget()\n\n    const outputInstance = new Output({\n      format: resolvedFormat,\n      target,\n    })\n\n    return {\n      mimeType: resolvedFormat.mimeType,\n      output: outputInstance,\n      target,\n    }\n  })\n\nconst makeVideoSource = (codec: ResolvedCodec) =>\n  Effect.sync(\n    () =>\n      new VideoSampleSource({\n        bitrate: QUALITY_HIGH,\n        codec,\n      })\n  )\n\nconst renderAndWriteFrame =\n  (\n    context: CanvasContext,\n    videoSource: VideoSampleSource,\n    frameDuration: number,\n    frameIndexRef: Ref.Ref<number>,\n    width: number,\n    height: number\n  ) =>\n  (frame: RenderFrame) =>\n    Effect.gen(function* () {\n      const frameIndex = yield* Ref.get(frameIndexRef)\n      renderFrame(context, width, height, frame)\n\n      const imageData = context.getImageData(0, 0, width, height)\n      const sample = new VideoSample(imageData.data, {\n        codedHeight: height,\n        codedWidth: width,\n        duration: frameDuration,\n        format: \"RGBA\",\n        timestamp: frameIndex * frameDuration,\n      })\n\n      yield* Effect.tryPromise({\n        catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n        try: () => videoSource.add(sample),\n      })\n\n      sample.close()\n      yield* Ref.set(frameIndexRef, frameIndex + 1)\n    })\n\nconst buildSceneFrames = (scene: Scene, blockFrames: number) =>\n  Stream.range(1, blockFrames).pipe(\n    Stream.map(\n      () =>\n        ({\n          background: scene.background,\n          kind: \"scene\",\n          opacity: 1,\n          positionX: scene.blockX,\n          positionY: scene.blockY,\n          scene,\n        }) satisfies RenderFrame\n    )\n  )\n\nconst buildTransitionFrames = (scene: Scene, nextScene: Scene, transitionFrames: number) => {\n  const diff = buildTransitionDiff(scene, nextScene)\n\n  return Stream.range(1, transitionFrames).pipe(\n    Stream.map((index) => {\n      const rawProgress = index / transitionFrames\n      const progress = easeInOutCubic(rawProgress)\n      const blendedBackground = blendColors(scene.background, nextScene.background, progress)\n      const tokens = buildTransitionTokens(diff, progress)\n\n      return {\n        background: blendedBackground,\n        kind: \"transition\",\n        tokens,\n      } satisfies RenderFrame\n    })\n  )\n}\n\nconst buildFramesStream = (scenes: Scene[], blockFrames: number, transitionFrames: number) =>\n  Stream.fromIterable(scenes).pipe(\n    Stream.zipWithIndex,\n    Stream.flatMap(([scene, index]) => {\n      const nextScene = scenes[index + 1]\n      const base = buildSceneFrames(scene, blockFrames)\n      return nextScene\n        ? Stream.concat(base, buildTransitionFrames(scene, nextScene, transitionFrames))\n        : base\n    })\n  )\n\ntype ResolvedCodec = \"avc\" | \"vp9\" | \"vp8\" | \"hevc\" | \"av1\"\n\ntype ResolvedFormat = {\n  codec: ResolvedCodec\n  container: \"mp4\" | \"webm\"\n}\n\nconst resolveFormat = (format: BrowserFormat, height: number, width: number) =>\n  Effect.gen(function* () {\n    if (format !== \"auto\") {\n      return {\n        codec: format === \"mp4\" ? \"avc\" : \"vp9\",\n        container: format,\n      } satisfies ResolvedFormat\n    }\n\n    const codec = yield* Effect.tryPromise({\n      catch: () =>\n        new NoEncodableVideoCodec({\n          reason: \"No encodable video codec available in this browser.\",\n        }),\n      try: () =>\n        getFirstEncodableVideoCodec([\"avc\", \"vp9\", \"vp8\"], {\n          bitrate: QUALITY_HIGH,\n          height,\n          width,\n        }),\n    })\n\n    if (!codec) {\n      return yield* Effect.fail(\n        new NoEncodableVideoCodec({\n          reason: \"No encodable video codec available in this browser.\",\n        })\n      )\n    }\n\n    return {\n      codec,\n      container: codec === \"avc\" ? \"mp4\" : \"webm\",\n    } satisfies ResolvedFormat\n  })\n\nconst resolveCanvas = (\n  canvas: CanvasLike | undefined,\n  height: number,\n  width: number,\n  createCanvas?: CanvasFactory\n) =>\n  Effect.gen(function* () {\n    if (canvas) {\n      const context = yield* getCanvasContext(canvas)\n\n      return {\n        canvas,\n        context,\n      }\n    }\n\n    if (!createCanvas) {\n      return yield* Effect.fail(\n        new MissingCanvasFactory({\n          reason: \"Browser canvas factory is required when no canvas is provided.\",\n        })\n      )\n    }\n\n    const created = createCanvas(height, width)\n    const context = yield* getCanvasContext(created)\n\n    return {\n      canvas: created,\n      context,\n    }\n  })\n\nexport const renderVideoBrowser = (\n  theme: string,\n  codeBlocks: CodeBlock[],\n  options: RenderVideoBrowserOptions = {}\n) =>\n  Effect.gen(function* () {\n    yield* ensureWebCodecs()\n\n    const width = options.width ?? DEFAULT_WIDTH\n    const height = options.height ?? DEFAULT_HEIGHT\n    const transitionDurationMs = options.transitionDurationMs ?? DEFAULT_TRANSITION_DURATION_MS\n    const format = options.format ?? \"auto\"\n\n    const { context } = yield* resolveCanvas(options.canvas, height, width, options.createCanvas)\n    const resolved = yield* resolveFormat(format, height, width)\n    const outputInfo = yield* makeOutput(resolved.container)\n    const frameCounts = computeFrameCounts(transitionDurationMs, DEFAULT_FPS)\n    const frameIndexRef = yield* Ref.make(0)\n\n    const scenes = yield* Effect.forEach(\n      codeBlocks,\n      (codeBlock) => buildScene(context, codeBlock, theme as never, width, height),\n      { concurrency: options.concurrency }\n    )\n\n    const videoSource = yield* makeVideoSource(resolved.codec)\n\n    return yield* Effect.scoped(\n      Effect.gen(function* () {\n        yield* Effect.sync(() => {\n          outputInfo.output.addVideoTrack(videoSource, { frameRate: DEFAULT_FPS })\n        })\n\n        yield* Effect.tryPromise({\n          catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n          try: () => outputInfo.output.start(),\n        })\n\n        const frameStream = buildFramesStream(\n          scenes,\n          frameCounts.blockFrames,\n          frameCounts.transitionFrames\n        )\n\n        yield* Stream.runForEach(\n          frameStream,\n          renderAndWriteFrame(\n            context,\n            videoSource,\n            frameCounts.frameDuration,\n            frameIndexRef,\n            width,\n            height\n          )\n        )\n\n        yield* Effect.tryPromise({\n          catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n          try: () => outputInfo.output.finalize(),\n        })\n\n        videoSource.close()\n\n        const buffer = outputInfo.target.buffer\n        if (!buffer) {\n          return yield* Effect.fail(\n            new OutputBufferMissing({\n              reason: \"Output buffer missing after finalize.\",\n            })\n          )\n        }\n\n        const output: BrowserOutput = {\n          data: new Uint8Array(buffer),\n          extension: resolved.container,\n          mimeType: outputInfo.mimeType,\n        }\n\n        return output\n      })\n    )\n  })\n"
  ],
  "mappings": "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",
  "debugId": "30C1AF8D08558A9464756E2164756E21",
  "names": []
}