sakuga 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adel Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+<div align="center">
+  <h1 align="center">sakuga</h1>
+
+  <p align="center">
+    <strong>Create code animations</strong>
+  </p>
+</div>
+
+Made with [🥐 `pastry`](https://github.com/adelrodriguez/pastry)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+declare const program: unknown;
+export { program };

package/dist/cli.js

@@ -0,0 +1,233 @@
+import {
+  DEFAULT_BLOCK_DURATION,
+  DEFAULT_FPS,
+  DEFAULT_HEIGHT,
+  DEFAULT_THEME,
+  DEFAULT_TRANSITION_DURATION_MS,
+  DEFAULT_WIDTH,
+  __require,
+  __toESM,
+  buildScene,
+  buildTransitionDiff,
+  buildTransitionTokens,
+  easeInOutCubic,
+  parseMarkdownCodeBlocks,
+  renderFrame,
+  resolveTheme
+} from "./shared/chunk-ks7faw1s.js";
+
+// src/cli.ts
+import { Args, Command, Options } from "@effect/cli";
+import { FileSystem, Path } from "@effect/platform";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Console, Effect as Effect3 } from "effect";
+
+// src/lib/video.ts
+import * as OS from "node:os";
+import { createCanvas } from "@napi-rs/canvas";
+import { Effect as Effect2, Ref, Stream } from "effect";
+import {
+  FilePathTarget,
+  Mp4OutputFormat,
+  Output,
+  QUALITY_HIGH,
+  VideoSample,
+  VideoSampleSource
+} from "mediabunny";
+
+// src/lib/webcodecs.ts
+import { Effect } from "effect";
+var ensureWebCodecs = () => Effect.tryPromise({
+  catch: (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const isMissingLibrary = message.includes("Library not loaded");
+    const baseMessage = "WebCodecs not available.";
+    const detailMessage = isMissingLibrary ? "Install FFmpeg (brew install ffmpeg) and ensure libavcodec is available." : "Install node-webcodecs plus FFmpeg (brew install ffmpeg pkg-config).";
+    return new Error(`${baseMessage} ${detailMessage}`, { cause: error });
+  },
+  try: async () => {
+    const globalScope = globalThis;
+    if (globalScope.VideoEncoder && globalScope.VideoFrame) {
+      return;
+    }
+    const webcodecs = await import("node-webcodecs");
+    const assignGlobal = (key, value) => {
+      if (globalScope[key]) {
+        return;
+      }
+      globalScope[key] = value;
+    };
+    assignGlobal("VideoEncoder", webcodecs.VideoEncoder);
+    assignGlobal("VideoFrame", webcodecs.VideoFrame);
+    assignGlobal("EncodedVideoChunk", webcodecs.EncodedVideoChunk);
+    assignGlobal("AudioEncoder", webcodecs.AudioEncoder);
+    assignGlobal("EncodedAudioChunk", webcodecs.EncodedAudioChunk);
+    assignGlobal("AudioData", webcodecs.AudioData);
+  }
+});
+
+// src/lib/video.ts
+var resolveConcurrency = () => Effect2.sync(() => Math.min(4, OS.availableParallelism()));
+var makeOutput = (outputPath) => Effect2.sync(() => new Output({
+  format: new Mp4OutputFormat,
+  target: new FilePathTarget(outputPath)
+}));
+var makeVideoSource = () => Effect2.sync(() => new VideoSampleSource({
+  bitrate: QUALITY_HIGH,
+  codec: "avc",
+  onEncoderConfig: (config) => {
+    const encoderConfig = config;
+    encoderConfig.useWorkerThread = false;
+  }
+}));
+var computeFrameCounts = (transitionDurationMs) => {
+  const frameDuration = 1 / DEFAULT_FPS;
+  const blockFrames = Math.max(1, Math.round(DEFAULT_BLOCK_DURATION * DEFAULT_FPS));
+  const transitionFrames = Math.max(1, Math.round(transitionDurationMs / 1000 * DEFAULT_FPS));
+  return {
+    blockFrames,
+    frameDuration,
+    transitionFrames
+  };
+};
+var renderAndWriteFrame = (context, output, videoSource, frameDuration, frameIndexRef) => (frame) => Effect2.gen(function* () {
+  const frameIndex = yield* Ref.get(frameIndexRef);
+  renderFrame(context, DEFAULT_WIDTH, DEFAULT_HEIGHT, frame);
+  const rgba = context.canvas.data();
+  const sample = new VideoSample(rgba, {
+    codedHeight: DEFAULT_HEIGHT,
+    codedWidth: DEFAULT_WIDTH,
+    duration: frameDuration,
+    format: "RGBA",
+    timestamp: frameIndex * frameDuration
+  });
+  yield* Effect2.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 blendColors = (from, to, progress) => {
+  const fromColor = parseHexColor(from);
+  const toColor = parseHexColor(to);
+  const blended = {
+    alpha: lerp(fromColor.alpha, toColor.alpha, progress),
+    blue: lerp(fromColor.blue, toColor.blue, progress),
+    green: lerp(fromColor.green, toColor.green, progress),
+    red: lerp(fromColor.red, toColor.red, progress)
+  };
+  return `rgba(${Math.round(blended.red)}, ${Math.round(blended.green)}, ${Math.round(blended.blue)}, ${blended.alpha.toFixed(3)})`;
+};
+var parseHexColor = (color) => {
+  const normalized = color.replace("#", "").trim();
+  if (normalized.length !== 6 && normalized.length !== 8) {
+    return {
+      alpha: 1,
+      blue: 11,
+      green: 11,
+      red: 11
+    };
+  }
+  const red = Number.parseInt(normalized.slice(0, 2), 16);
+  const green = Number.parseInt(normalized.slice(2, 4), 16);
+  const blue = Number.parseInt(normalized.slice(4, 6), 16);
+  const alpha = normalized.length === 8 ? Number.parseInt(normalized.slice(6, 8), 16) / 255 : 1;
+  return {
+    alpha,
+    blue,
+    green,
+    red
+  };
+};
+var lerp = (start, end, progress) => start + (end - start) * progress;
+var renderVideo = (outputPath, theme, codeBlocks, options = {}) => Effect2.gen(function* () {
+  yield* ensureWebCodecs();
+  const concurrency = options.concurrency ?? (yield* resolveConcurrency());
+  const transitionDurationMs = options.transitionDurationMs ?? DEFAULT_TRANSITION_DURATION_MS;
+  const canvas = createCanvas(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+  const context = canvas.getContext("2d");
+  const scenes = yield* Effect2.forEach(codeBlocks, (codeBlock) => buildScene(context, codeBlock, theme, DEFAULT_WIDTH, DEFAULT_HEIGHT), { concurrency });
+  const frameCounts = computeFrameCounts(transitionDurationMs);
+  const frameIndexRef = yield* Ref.make(0);
+  return yield* Effect2.scoped(Effect2.gen(function* () {
+    const output = yield* Effect2.acquireRelease(makeOutput(outputPath), (resource) => Effect2.tryPromise({
+      catch: (error) => error instanceof Error ? error : new Error(String(error)),
+      try: () => resource.finalize()
+    }).pipe(Effect2.orDie));
+    const videoSource = yield* Effect2.acquireRelease(makeVideoSource(), (resource) => Effect2.sync(() => {
+      resource.close();
+    }));
+    yield* Effect2.sync(() => {
+      output.addVideoTrack(videoSource, { frameRate: DEFAULT_FPS });
+    });
+    yield* Effect2.tryPromise({
+      catch: (error) => error instanceof Error ? error : new Error(String(error)),
+      try: () => output.start()
+    });
+    const frameStream = buildFramesStream(scenes, frameCounts.blockFrames, frameCounts.transitionFrames);
+    yield* Stream.runForEach(frameStream, renderAndWriteFrame(context, output, videoSource, frameCounts.frameDuration, frameIndexRef));
+    return outputPath;
+  }));
+});
+
+// src/cli.ts
+var version = await "0.0.1";
+var file = Args.file({ exists: "yes", name: "file" });
+var theme = Options.text("theme").pipe(Options.withAlias("t"), Options.withDefault(DEFAULT_THEME), Options.withDescription("Shiki theme for syntax highlighting."));
+var transition = Options.integer("transition").pipe(Options.withAlias("tr"), Options.withDefault(DEFAULT_TRANSITION_DURATION_MS), Options.withDescription("Transition duration between slides in milliseconds."));
+var main = Command.make("looney", { file, theme, transition }).pipe(Command.withDescription("Create code animation videos from Markdown."), Command.withHandler(({ file: file2, theme: theme2, transition: transition2 }) => Effect3.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const markdown = yield* fs.readFileString(file2);
+  const blocks = yield* parseMarkdownCodeBlocks(markdown);
+  if (blocks.length === 0) {
+    yield* Effect3.fail(new Error("No fenced code blocks found."));
+  }
+  if (transition2 <= 0) {
+    yield* Effect3.fail(new Error("Transition duration must be greater than 0."));
+  }
+  const resolvedTheme = yield* resolveTheme(theme2);
+  const parsedOutputPath = path.parse(file2);
+  const outputPath = path.join(parsedOutputPath.dir, `${parsedOutputPath.name}.mp4`);
+  yield* Console.log(`Rendering ${blocks.length} code blocks...`);
+  yield* renderVideo(outputPath, resolvedTheme, blocks, {
+    transitionDurationMs: transition2
+  });
+  yield* Console.log(`Video created at ${outputPath}`);
+})));
+var program = Command.run(main, { name: "looney", version });
+program(process.argv).pipe(Effect3.tapErrorCause(Effect3.logError), Effect3.provide(NodeContext.layer), NodeRuntime.runMain);
+export {
+  program
+};
+
+//# debugId=327D1771FEFA40CD64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/cli.ts", "src/lib/video.ts", "src/lib/webcodecs.ts"],
  "sourcesContent": [
    "import { Args, Command, Options } from \"@effect/cli\"\nimport { FileSystem, Path } from \"@effect/platform\"\nimport { NodeContext, NodeRuntime } from \"@effect/platform-node\"\nimport { Console, Effect } from \"effect\"\nimport { DEFAULT_THEME, DEFAULT_TRANSITION_DURATION_MS } from \"./lib/constants\"\nimport { parseMarkdownCodeBlocks } from \"./lib/markdown\"\nimport { resolveTheme } from \"./lib/theme\"\nimport { renderVideo } from \"./lib/video\"\nimport { readVersion } from \"./version\" with { type: \"macro\" }\n\nconst version = await readVersion()\n\nconst file = Args.file({ exists: \"yes\", name: \"file\" })\nconst theme = Options.text(\"theme\").pipe(\n  Options.withAlias(\"t\"),\n  Options.withDefault(DEFAULT_THEME),\n  Options.withDescription(\"Shiki theme for syntax highlighting.\")\n)\nconst transition = Options.integer(\"transition\").pipe(\n  Options.withAlias(\"tr\"),\n  Options.withDefault(DEFAULT_TRANSITION_DURATION_MS),\n  Options.withDescription(\"Transition duration between slides in milliseconds.\")\n)\n\nconst main = Command.make(\"looney\", { file, theme, transition }).pipe(\n  Command.withDescription(\"Create code animation videos from Markdown.\"),\n  Command.withHandler(({ file, theme, transition }) =>\n    Effect.gen(function* () {\n      const fs = yield* FileSystem.FileSystem\n      const path = yield* Path.Path\n\n      const markdown = yield* fs.readFileString(file)\n      const blocks = yield* parseMarkdownCodeBlocks(markdown)\n\n      if (blocks.length === 0) {\n        yield* Effect.fail(new Error(\"No fenced code blocks found.\"))\n      }\n\n      if (transition <= 0) {\n        yield* Effect.fail(new Error(\"Transition duration must be greater than 0.\"))\n      }\n\n      const resolvedTheme = yield* resolveTheme(theme)\n      const parsedOutputPath = path.parse(file)\n      const outputPath = path.join(parsedOutputPath.dir, `${parsedOutputPath.name}.mp4`)\n\n      yield* Console.log(`Rendering ${blocks.length} code blocks...`)\n      yield* renderVideo(outputPath, resolvedTheme, blocks, {\n        transitionDurationMs: transition,\n      })\n      yield* Console.log(`Video created at ${outputPath}`)\n    })\n  )\n)\n\nexport const program = Command.run(main, { name: \"looney\", version })\n\nprogram(process.argv).pipe(\n  Effect.tapErrorCause(Effect.logError),\n  Effect.provide(NodeContext.layer),\n  NodeRuntime.runMain\n)\n",
    "import * as OS from \"node:os\"\nimport { createCanvas, type SKRSContext2D } from \"@napi-rs/canvas\"\nimport { Effect, Ref, Stream } from \"effect\"\nimport {\n  FilePathTarget,\n  Mp4OutputFormat,\n  Output,\n  QUALITY_HIGH,\n  VideoSample,\n  VideoSampleSource,\n} from \"mediabunny\"\nimport type { CanvasContext } from \"./context\"\nimport type { CodeBlock, RenderFrame, Scene } from \"./types\"\nimport {\n  DEFAULT_BLOCK_DURATION,\n  DEFAULT_FPS,\n  DEFAULT_HEIGHT,\n  DEFAULT_TRANSITION_DURATION_MS,\n  DEFAULT_WIDTH,\n} from \"./constants\"\nimport { renderFrame } from \"./render\"\nimport { buildScene } from \"./scene\"\nimport { buildTransitionDiff, buildTransitionTokens, easeInOutCubic } from \"./transition\"\nimport { ensureWebCodecs } from \"./webcodecs\"\n\nexport type RenderVideoOptions = {\n  concurrency?: number\n  transitionDurationMs?: number\n}\n\nconst resolveConcurrency = () => Effect.sync(() => Math.min(4, OS.availableParallelism()))\n\nconst makeOutput = (outputPath: string) =>\n  Effect.sync(\n    () =>\n      new Output({\n        format: new Mp4OutputFormat(),\n        target: new FilePathTarget(outputPath),\n      })\n  )\n\nconst makeVideoSource = () =>\n  Effect.sync(\n    () =>\n      new VideoSampleSource({\n        bitrate: QUALITY_HIGH,\n        codec: \"avc\",\n        onEncoderConfig: (config) => {\n          const encoderConfig = config as { useWorkerThread?: boolean }\n          encoderConfig.useWorkerThread = false\n        },\n      })\n  )\n\nconst computeFrameCounts = (transitionDurationMs: number) => {\n  const frameDuration = 1 / DEFAULT_FPS\n  const blockFrames = Math.max(1, Math.round(DEFAULT_BLOCK_DURATION * DEFAULT_FPS))\n  const transitionFrames = Math.max(1, Math.round((transitionDurationMs / 1000) * DEFAULT_FPS))\n\n  return {\n    blockFrames,\n    frameDuration,\n    transitionFrames,\n  }\n}\n\nconst renderAndWriteFrame =\n  (\n    context: CanvasContext,\n    output: Output,\n    videoSource: VideoSampleSource,\n    frameDuration: number,\n    frameIndexRef: Ref.Ref<number>\n  ) =>\n  (frame: RenderFrame) =>\n    Effect.gen(function* () {\n      const frameIndex = yield* Ref.get(frameIndexRef)\n      renderFrame(context, DEFAULT_WIDTH, DEFAULT_HEIGHT, frame)\n\n      const rgba = (context as SKRSContext2D).canvas.data()\n      const sample = new VideoSample(rgba, {\n        codedHeight: DEFAULT_HEIGHT,\n        codedWidth: DEFAULT_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\nconst blendColors = (from: string, to: string, progress: number) => {\n  const fromColor = parseHexColor(from)\n  const toColor = parseHexColor(to)\n\n  const blended = {\n    alpha: lerp(fromColor.alpha, toColor.alpha, progress),\n    blue: lerp(fromColor.blue, toColor.blue, progress),\n    green: lerp(fromColor.green, toColor.green, progress),\n    red: lerp(fromColor.red, toColor.red, progress),\n  }\n\n  return `rgba(${Math.round(blended.red)}, ${Math.round(blended.green)}, ${Math.round(\n    blended.blue\n  )}, ${blended.alpha.toFixed(3)})`\n}\n\nconst parseHexColor = (color: string) => {\n  const normalized = color.replace(\"#\", \"\").trim()\n  if (normalized.length !== 6 && normalized.length !== 8) {\n    return {\n      alpha: 1,\n      blue: 11,\n      green: 11,\n      red: 11,\n    }\n  }\n\n  const red = Number.parseInt(normalized.slice(0, 2), 16)\n  const green = Number.parseInt(normalized.slice(2, 4), 16)\n  const blue = Number.parseInt(normalized.slice(4, 6), 16)\n  const alpha = normalized.length === 8 ? Number.parseInt(normalized.slice(6, 8), 16) / 255 : 1\n\n  return {\n    alpha,\n    blue,\n    green,\n    red,\n  }\n}\n\nconst lerp = (start: number, end: number, progress: number) => start + (end - start) * progress\n\nexport const renderVideo = (\n  outputPath: string,\n  theme: string,\n  codeBlocks: CodeBlock[],\n  options: RenderVideoOptions = {}\n) =>\n  Effect.gen(function* () {\n    yield* ensureWebCodecs()\n\n    const concurrency = options.concurrency ?? (yield* resolveConcurrency())\n    const transitionDurationMs = options.transitionDurationMs ?? DEFAULT_TRANSITION_DURATION_MS\n\n    const canvas = createCanvas(DEFAULT_WIDTH, DEFAULT_HEIGHT)\n    const context = canvas.getContext(\"2d\")\n\n    const scenes = yield* Effect.forEach(\n      codeBlocks,\n      (codeBlock) => buildScene(context, codeBlock, theme as never, DEFAULT_WIDTH, DEFAULT_HEIGHT),\n      { concurrency }\n    )\n\n    const frameCounts = computeFrameCounts(transitionDurationMs)\n    const frameIndexRef = yield* Ref.make(0)\n\n    return yield* Effect.scoped(\n      Effect.gen(function* () {\n        const output = yield* Effect.acquireRelease(makeOutput(outputPath), (resource) =>\n          Effect.tryPromise({\n            catch: (error) => (error instanceof Error ? error : new Error(String(error))),\n            try: () => resource.finalize(),\n          }).pipe(Effect.orDie)\n        )\n        const videoSource = yield* Effect.acquireRelease(makeVideoSource(), (resource) =>\n          Effect.sync(() => {\n            resource.close()\n          })\n        )\n\n        yield* Effect.sync(() => {\n          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: () => 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            output,\n            videoSource,\n            frameCounts.frameDuration,\n            frameIndexRef\n          )\n        )\n\n        return outputPath\n      })\n    )\n  })\n",
    "import { Effect } from \"effect\"\n\nexport type WebCodecsGlobals = {\n  AudioData?: unknown\n  AudioEncoder?: unknown\n  EncodedAudioChunk?: unknown\n  EncodedVideoChunk?: unknown\n  VideoEncoder?: unknown\n  VideoFrame?: unknown\n}\n\nexport const ensureWebCodecs = () =>\n  Effect.tryPromise({\n    catch: (error) => {\n      const message = error instanceof Error ? error.message : String(error)\n      const isMissingLibrary = message.includes(\"Library not loaded\")\n      const baseMessage = \"WebCodecs not available.\"\n      const detailMessage = isMissingLibrary\n        ? \"Install FFmpeg (brew install ffmpeg) and ensure libavcodec is available.\"\n        : \"Install node-webcodecs plus FFmpeg (brew install ffmpeg pkg-config).\"\n\n      return new Error(`${baseMessage} ${detailMessage}`, { cause: error })\n    },\n    try: async () => {\n      const globalScope = globalThis as typeof globalThis & WebCodecsGlobals\n      if (globalScope.VideoEncoder && globalScope.VideoFrame) {\n        return\n      }\n\n      const webcodecs = (await import(\"node-webcodecs\")) as Record<string, unknown>\n\n      const assignGlobal = (key: keyof WebCodecsGlobals, value: unknown) => {\n        if (globalScope[key]) {\n          return\n        }\n\n        ;(globalScope as Record<string, unknown>)[key] = value\n      }\n\n      assignGlobal(\"VideoEncoder\", webcodecs.VideoEncoder)\n      assignGlobal(\"VideoFrame\", webcodecs.VideoFrame)\n      assignGlobal(\"EncodedVideoChunk\", webcodecs.EncodedVideoChunk)\n      assignGlobal(\"AudioEncoder\", webcodecs.AudioEncoder)\n      assignGlobal(\"EncodedAudioChunk\", webcodecs.EncodedAudioChunk)\n      assignGlobal(\"AudioData\", webcodecs.AudioData)\n    },\n  })\n"
  ],
  "mappings": "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",
  "debugId": "327D1771FEFA40CD64756E2164756E21",
  "names": []
}

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+type CanvasMeasure = {
+	font: string;
+	measureText: (text: string) => {
+		width: number;
+	};
+};
+type CanvasText = {
+	fillStyle: unknown;
+	font: string;
+	globalAlpha: number;
+	lineWidth: number;
+	strokeStyle: unknown;
+	textAlign: string;
+	textBaseline: string;
+	beginPath: () => void;
+	fillRect: (x: number, y: number, width: number, height: number) => void;
+	fillText: (text: string, x: number, y: number) => void;
+	getImageData: (x: number, y: number, width: number, height: number) => {
+		data: Uint8ClampedArray;
+	};
+	getTransform: () => unknown;
+	lineTo: (x: number, y: number) => void;
+	moveTo: (x: number, y: number) => void;
+	setTransform: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+	setTransformMatrix?: (transform: unknown) => void;
+	stroke: () => void;
+};
+type CanvasContext = CanvasMeasure & CanvasText & {
+	canvas?: unknown;
+};
+type BrowserFormat = "mp4" | "webm" | "auto";
+type CanvasLike = {
+	getContext: (type: "2d") => CanvasContext | null;
+	height: number;
+	width: number;
+};
+type CanvasFactory = (height: number, width: number) => CanvasLike;
+type BrowserOutput = {
+	data: Uint8Array;
+	extension: "mp4" | "webm";
+	mimeType: string;
+};
+type RenderVideoBrowserOptions = {
+	canvas?: CanvasLike;
+	concurrency?: number;
+	createCanvas?: CanvasFactory;
+	format?: BrowserFormat;
+	height?: number;
+	transitionDurationMs?: number;
+	width?: number;
+};
+declare const renderVideoBrowser: unknown;
+declare const parseMarkdownCodeBlocks: unknown;
+import { Effect } from "effect";
+type RenderOptions = RenderVideoBrowserOptions & {
+	markdown: string;
+	theme?: string;
+};
+type RenderResult = ReturnType<typeof renderVideoBrowser> extends Effect.Effect<infer A, unknown> ? A : never;
+declare const render: unknown;
+type CodeBlock = {
+	code: string;
+	language: string;
+};
+type LayoutToken = {
+	color: string;
+	content: string;
+	fontStyle: number;
+	width: number;
+	x: number;
+	y: number;
+};
+type TransitionDiff = {
+	added: LayoutToken[];
+	matched: Array<{
+		from: LayoutToken;
+		to: LayoutToken;
+	}>;
+	removed: LayoutToken[];
+};
+declare const diffLayoutTokens: (fromTokens: LayoutToken[], toTokens: LayoutToken[]) => {};
+export { render, parseMarkdownCodeBlocks, diffLayoutTokens, TransitionDiff, RenderVideoBrowserOptions, RenderResult, RenderOptions, LayoutToken, CodeBlock, CanvasLike, CanvasFactory, BrowserOutput, BrowserFormat };