vizcore 0.1.0 → 1.1.0

data/frontend/src/visuals/svg-arc.js

@@ -0,0 +1,104 @@
+export const describeSvgArc = ({ from, to, rx, ry, xAxisRotation = 0, largeArc = false, sweep = false }) => {
+  const start = pointPair(from);
+  const end = pointPair(to);
+  if (!start || !end) return null;
+  if (samePoint(start, end)) return null;
+
+  let radiusX = Math.abs(finiteNumber(rx, 0));
+  let radiusY = Math.abs(finiteNumber(ry, 0));
+  if (radiusX <= 0 || radiusY <= 0) return null;
+
+  const rotation = (finiteNumber(xAxisRotation, 0) / 180) * Math.PI;
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const dx = (start[0] - end[0]) / 2;
+  const dy = (start[1] - end[1]) / 2;
+  const x1p = cos * dx + sin * dy;
+  const y1p = -sin * dx + cos * dy;
+
+  const radiusScale = ((x1p * x1p) / (radiusX * radiusX)) + ((y1p * y1p) / (radiusY * radiusY));
+  if (radiusScale > 1) {
+    const scale = Math.sqrt(radiusScale);
+    radiusX *= scale;
+    radiusY *= scale;
+  }
+
+  const rx2 = radiusX * radiusX;
+  const ry2 = radiusY * radiusY;
+  const x1p2 = x1p * x1p;
+  const y1p2 = y1p * y1p;
+  const denominator = (rx2 * y1p2) + (ry2 * x1p2);
+  if (denominator === 0) return null;
+
+  const numerator = Math.max(0, (rx2 * ry2) - (rx2 * y1p2) - (ry2 * x1p2));
+  const sign = Boolean(largeArc) === Boolean(sweep) ? -1 : 1;
+  const coefficient = sign * Math.sqrt(numerator / denominator);
+  const cxp = coefficient * ((radiusX * y1p) / radiusY);
+  const cyp = coefficient * (-(radiusY * x1p) / radiusX);
+  const cx = (cos * cxp) - (sin * cyp) + ((start[0] + end[0]) / 2);
+  const cy = (sin * cxp) + (cos * cyp) + ((start[1] + end[1]) / 2);
+
+  const startVector = [(x1p - cxp) / radiusX, (y1p - cyp) / radiusY];
+  const endVector = [(-x1p - cxp) / radiusX, (-y1p - cyp) / radiusY];
+  const startAngle = vectorAngle([1, 0], startVector);
+  let deltaAngle = vectorAngle(startVector, endVector);
+
+  if (!sweep && deltaAngle > 0) {
+    deltaAngle -= Math.PI * 2;
+  } else if (sweep && deltaAngle < 0) {
+    deltaAngle += Math.PI * 2;
+  }
+
+  return {
+    cx,
+    cy,
+    rx: radiusX,
+    ry: radiusY,
+    rotation,
+    startAngle,
+    deltaAngle
+  };
+};
+
+export const svgArcPoint = (arc, progress) => {
+  const angle = arc.startAngle + (arc.deltaAngle * progress);
+  const cosRotation = Math.cos(arc.rotation);
+  const sinRotation = Math.sin(arc.rotation);
+  const x = Math.cos(angle) * arc.rx;
+  const y = Math.sin(angle) * arc.ry;
+
+  return [
+    arc.cx + (cosRotation * x) - (sinRotation * y),
+    arc.cy + (sinRotation * x) + (cosRotation * y)
+  ];
+};
+
+export const svgArcSegmentCount = (arc, detail = 32) => {
+  const safeDetail = clampInt(detail, 4, 128);
+  return Math.max(1, Math.ceil((Math.abs(arc.deltaAngle) / (Math.PI * 2)) * safeDetail));
+};
+
+const pointPair = (value) => {
+  if (!Array.isArray(value) || value.length < 2) return null;
+
+  return [finiteNumber(value[0], 0), finiteNumber(value[1], 0)];
+};
+
+const samePoint = (a, b) => Math.abs(a[0] - b[0]) < 1e-9 && Math.abs(a[1] - b[1]) < 1e-9;
+
+const vectorAngle = (from, to) => {
+  const cross = (from[0] * to[1]) - (from[1] * to[0]);
+  const dot = (from[0] * to[0]) + (from[1] * to[1]);
+  return Math.atan2(cross, dot);
+};
+
+const clampInt = (value, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return min;
+  return Math.round(Math.min(Math.max(numeric, min), max));
+};
+
+const finiteNumber = (value, fallback) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+};

data/frontend/src/visuals/text-renderer.js

@@ -55,9 +55,9 @@ export class TextRenderer {
     this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
   }
 
-  render({ content, fontSize, audio, time, color, glowStrength }) {
-    const text = String(content || "").trim();
-    if (!text) {
+  render({ content, fontSize, audio, time, color, fontFamily, align, letterSpacing, strokeWidth, strokeColor, shadowColor, shadowBlur, glowStrength }) {
+    const lines = normalizeTextLines(content);
+    if (!lines.length) {
       return;
     }
 
@@ -65,15 +65,24 @@ export class TextRenderer {
 
     const amp = clamp(Number(audio?.amplitude || 0), 0, 1);
     const beatBoost = audio?.beat ? 1.0 : 0.0;
-    const maxFontSize = Math.max(48, Math.floor(this.canvas.height * 0.22));
+    const singleLineMax = Math.floor(this.canvas.height * 0.22);
+    const multilineMax = Math.floor((this.canvas.height * 0.58) / Math.max(lines.length, 1));
+    const maxFontSize = Math.max(32, Math.min(singleLineMax, multilineMax));
     const dynamicSize = Math.round(
       clamp(Number(fontSize || 96), 18, maxFontSize) * (1 + amp * 0.08 + beatBoost * 0.04)
     );
     this.drawTextToCanvas({
-      text,
+      lines,
       fontSize: dynamicSize,
       time,
       color,
+      fontFamily,
+      align,
+      letterSpacing,
+      strokeWidth,
+      strokeColor,
+      shadowColor,
+      shadowBlur,
       amplitude: amp,
       glowStrength: Number(glowStrength ?? 0.15)
     });
@@ -81,7 +90,7 @@ export class TextRenderer {
     this.drawQuad({ intensity: 0.85 + amp * 0.15 });
   }
 
-  drawTextToCanvas({ text, fontSize, time, color, amplitude, glowStrength }) {
+  drawTextToCanvas({ lines, fontSize, time, color, fontFamily, align, letterSpacing, strokeWidth, strokeColor, shadowColor, shadowBlur, amplitude, glowStrength }) {
     const ctx = this.ctx;
     ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
 
@@ -91,14 +100,30 @@ export class TextRenderer {
     const safeColor = typeof color === "string" && color.trim() ? color : "#e5f3ff";
     const glow = clamp(Number(glowStrength || 0), 0, 1) * (1.5 + amplitude * 5.0);
     const xShift = Math.sin(time * 2.0) * (2 + amplitude * 4);
+    const textAlign = normalizeTextAlign(align);
+    const spacing = normalizeLetterSpacing(letterSpacing);
+    const stroke = clamp(Number(strokeWidth || 0), 0, 24);
+    const shadow = shadowBlur === undefined ? glow : clamp(Number(shadowBlur || 0), 0, 80);
 
-    ctx.textAlign = "center";
+    ctx.textAlign = textAlign;
     ctx.textBaseline = "middle";
-    ctx.font = `700 ${fontSize}px "IBM Plex Sans", "Noto Sans JP", sans-serif`;
-    ctx.shadowColor = "rgba(110, 208, 255, 0.35)";
-    ctx.shadowBlur = glow;
+    ctx.font = `700 ${fontSize}px ${normalizeFontFamily(fontFamily)}`;
+    ctx.shadowColor = normalizeTextColor(shadowColor, "rgba(110, 208, 255, 0.35)");
+    ctx.shadowBlur = shadow;
     ctx.fillStyle = safeColor;
-    ctx.fillText(text, this.canvas.width / 2 + xShift, this.canvas.height / 2);
+    const x = resolveTextX(this.canvas.width, textAlign) + xShift;
+    const lineHeight = fontSize * 1.16;
+    const startY = this.canvas.height / 2 - ((lines.length - 1) * lineHeight) / 2;
+    lines.forEach((line, index) => {
+      const y = startY + index * lineHeight;
+      if (stroke > 0) {
+        ctx.lineJoin = "round";
+        ctx.lineWidth = stroke;
+        ctx.strokeStyle = normalizeTextColor(strokeColor, safeColor);
+        drawText(ctx, { text: line, x, y, align: textAlign, letterSpacing: spacing, method: "strokeText" });
+      }
+      drawText(ctx, { text: line, x, y, align: textAlign, letterSpacing: spacing, method: "fillText" });
+    });
   }
 
   syncCanvasSize() {
@@ -141,3 +166,79 @@ export class TextRenderer {
 }
 
 const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+
+export const normalizeTextAlign = (value) => {
+  const align = String(value || "center").trim().toLowerCase();
+  if (align === "left" || align === "right" || align === "center") {
+    return align;
+  }
+  return "center";
+};
+
+export const resolveTextX = (width, align) => {
+  const canvasWidth = Number(width) || 0;
+  if (align === "left") return canvasWidth * 0.12;
+  if (align === "right") return canvasWidth * 0.88;
+  return canvasWidth * 0.5;
+};
+
+export const normalizeTextLines = (value) => {
+  return String(value || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .slice(0, 6);
+};
+
+export const normalizeLetterSpacing = (value) => {
+  const spacing = Number(value);
+  if (!Number.isFinite(spacing)) return 0;
+  return clamp(spacing, 0, 96);
+};
+
+export const measureLetterSpacedText = (ctx, text, letterSpacing = 0) => {
+  const chars = Array.from(String(text || ""));
+  if (!chars.length) return 0;
+
+  const spacing = normalizeLetterSpacing(letterSpacing);
+  const glyphWidth = chars.reduce((total, char) => {
+    return total + Number(ctx.measureText(char)?.width || 0);
+  }, 0);
+  return glyphWidth + spacing * (chars.length - 1);
+};
+
+export const resolveLetterSpacedStartX = (ctx, text, x, align, letterSpacing = 0) => {
+  const width = measureLetterSpacedText(ctx, text, letterSpacing);
+  if (align === "right") return x - width;
+  if (align === "center") return x - width / 2;
+  return x;
+};
+
+export const normalizeFontFamily = (value) => {
+  const family = String(value || "").trim();
+  if (!family) return "\"IBM Plex Sans\", \"Noto Sans JP\", sans-serif";
+  if (family.includes(",")) return `${family}, "IBM Plex Sans", "Noto Sans JP", sans-serif`;
+
+  return `"${family.replaceAll("\"", "")}", "IBM Plex Sans", "Noto Sans JP", sans-serif`;
+};
+
+const normalizeTextColor = (value, fallback) => {
+  const color = String(value || "").trim();
+  return color || fallback;
+};
+
+const drawText = (ctx, { text, x, y, align, letterSpacing, method }) => {
+  if (letterSpacing <= 0) {
+    ctx[method](text, x, y);
+    return;
+  }
+
+  const originalAlign = ctx.textAlign;
+  ctx.textAlign = "left";
+  let cursor = resolveLetterSpacedStartX(ctx, text, x, align, letterSpacing);
+  for (const char of Array.from(text)) {
+    ctx[method](char, cursor, y);
+    cursor += Number(ctx.measureText(char)?.width || 0) + letterSpacing;
+  }
+  ctx.textAlign = originalAlign;
+};

data/frontend/src/websocket-client.js

@@ -1,6 +1,7 @@
 const RECONNECT_INTERVAL_MS = 1000;
 const READY_STATE_CONNECTING = 0;
 const READY_STATE_OPEN = 1;
+export const PROTOCOL_VERSION = "vizcore.frame.v1";
 
 export class WebSocketClient {
   constructor(url, callbacks = {}) {
@@ -8,6 +9,7 @@ export class WebSocketClient {
     this.onFrame = callbacks.onFrame || (() => {});
     this.onSceneChange = callbacks.onSceneChange || (() => {});
     this.onConfigUpdate = callbacks.onConfigUpdate || (() => {});
+    this.onLatencyProbe = callbacks.onLatencyProbe || (() => {});
     this.onStatus = callbacks.onStatus || (() => {});
     this.socket = null;
     this.reconnectTimer = null;
@@ -97,6 +99,10 @@ export class WebSocketClient {
       return;
     }
 
+    if (message.protocol && message.protocol !== PROTOCOL_VERSION) {
+      return;
+    }
+
     if (message.type === "audio_frame") {
       this.onFrame(message.payload);
       return;
@@ -109,6 +115,11 @@ export class WebSocketClient {
 
     if (message.type === "config_update") {
       this.onConfigUpdate(message.payload);
+      return;
+    }
+
+    if (message.type === "latency_probe") {
+      this.onLatencyProbe(message.payload);
     }
   }
 
@@ -122,7 +133,7 @@ export class WebSocketClient {
     }
 
     try {
-      this.socket.send(JSON.stringify({ type, payload }));
+      this.socket.send(JSON.stringify({ protocol: PROTOCOL_VERSION, type, payload }));
       return true;
     } catch {
       return false;

data/lib/vizcore/analysis/adaptive_normalizer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Vizcore
+  module Analysis
+    # Scales audio features against a rolling amplitude peak for repeatable mappings.
+    class AdaptiveNormalizer
+      DEFAULT_WINDOW_SIZE = 128
+      DEFAULT_TARGET = 0.85
+      DEFAULT_FLOOR = 0.05
+
+      # @param window_size [Integer] number of recent active frames used to track the peak
+      # @param target [Numeric] desired level for the rolling peak
+      # @param floor [Numeric] minimum peak level used when calculating gain
+      def initialize(window_size: DEFAULT_WINDOW_SIZE, target: DEFAULT_TARGET, floor: DEFAULT_FLOOR)
+        @window_size = normalize_window_size(window_size)
+        @target = normalize_unit(target, DEFAULT_TARGET)
+        @floor = normalize_unit(floor, DEFAULT_FLOOR)
+        @history = []
+      end
+
+      # @param amplitude [Numeric] current RMS amplitude
+      # @param bands [Hash] current frequency band values
+      # @param fft [Array<Numeric>] current FFT preview values
+      # @return [Hash] normalized feature values plus the applied gain
+      def call(amplitude:, bands:, fft:)
+        current_amplitude = normalize_unit(amplitude, 0.0)
+        @history << current_amplitude
+        @history.shift while @history.length > @window_size
+
+        gain = @target / [@history.max.to_f, @floor].max
+        {
+          amplitude: scale_value(current_amplitude, gain),
+          bands: scale_hash(bands, gain),
+          fft: scale_array(fft, gain),
+          gain: gain
+        }
+      end
+
+      private
+
+      def normalize_window_size(value)
+        Integer(value).clamp(1, 10_000)
+      rescue ArgumentError, TypeError
+        DEFAULT_WINDOW_SIZE
+      end
+
+      def normalize_unit(value, fallback)
+        Float(value).clamp(0.0, 1.0)
+      rescue ArgumentError, TypeError
+        fallback
+      end
+
+      def scale_hash(values, gain)
+        Hash(values).transform_values { |value| scale_value(value, gain) }
+      rescue StandardError
+        {}
+      end
+
+      def scale_array(values, gain)
+        Array(values).map { |value| scale_value(value, gain) }
+      end
+
+      def scale_value(value, gain)
+        (Float(value) * gain).clamp(0.0, 1.0)
+      rescue ArgumentError, TypeError
+        0.0
+      end
+    end
+  end
+end

data/lib/vizcore/analysis/beat_detector.rb

@@ -10,11 +10,13 @@ module Vizcore
       # @param sensitivity [Float] multiplier applied to moving average energy
       # @param refractory_frames [Integer] minimum frames between beat events
       # @param min_history [Integer] minimum history size before detecting beats
-      def initialize(history_size: 43, sensitivity: 1.35, refractory_frames: 4, min_history: 8)
+      # @param min_energy [Float] absolute energy floor required for beat detection
+      def initialize(history_size: 43, sensitivity: 1.35, refractory_frames: 4, min_history: 8, min_energy: 1e-6)
         @history_size = Integer(history_size)
         @sensitivity = Float(sensitivity)
         @refractory_frames = Integer(refractory_frames)
         @min_history = Integer(min_history)
+        @min_energy = Float(min_energy)
         @energy_history = []
         @frame_index = 0
         @last_beat_frame = -@refractory_frames
@@ -29,7 +31,7 @@ module Vizcore
         threshold = average_energy * @sensitivity
         enough_history = @energy_history.length >= @min_history
         refractory_ok = (@frame_index - @last_beat_frame) > @refractory_frames
-        beat = enough_history && refractory_ok && instant_energy > threshold && instant_energy.positive?
+        beat = enough_history && refractory_ok && instant_energy > threshold && instant_energy >= @min_energy
 
         if beat
           @beat_count += 1

data/lib/vizcore/analysis/bpm_estimator.rb

@@ -44,6 +44,14 @@ module Vizcore
         @current_bpm
       end
 
+      # Clear accumulated onset history and the current tempo estimate.
+      #
+      # @return [void]
+      def reset
+        @history.clear
+        @current_bpm = 0.0
+      end
+
       private
 
       def onset_count

data/lib/vizcore/analysis/feature_recorder.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+require_relative "../audio/file_input"
+require_relative "../audio/input_manager"
+require_relative "pipeline"
+
+module Vizcore
+  module Analysis
+    # Records deterministic audio analysis features from a file source.
+    class FeatureRecorder
+      VERSION = "vizcore.features.v1"
+      DEFAULT_FRAME_COUNT = 300
+      DEFAULT_FRAME_RATE = 30.0
+
+      def initialize(
+        audio_file:,
+        frames: DEFAULT_FRAME_COUNT,
+        fps: DEFAULT_FRAME_RATE,
+        noise_gate: Pipeline::DEFAULT_NOISE_GATE,
+        audio_normalize: nil,
+        bpm: nil,
+        bpm_lock: false
+      )
+        @audio_file = Pathname.new(audio_file.to_s).expand_path
+        @frames = normalize_frame_count(frames)
+        @fps = normalize_frame_rate(fps)
+        @noise_gate = Float(noise_gate)
+        @audio_normalize = audio_normalize
+        @bpm = bpm
+        @bpm_lock = bpm_lock
+      end
+
+      # @param out [String, Pathname] JSON output path
+      # @return [Hash] recorder metadata
+      def write(out:)
+        output_path = Pathname.new(out.to_s).expand_path
+        FileUtils.mkdir_p(output_path.dirname)
+        payload = record
+        output_path.write("#{JSON.pretty_generate(payload)}\n")
+        {
+          path: output_path,
+          frames: @frames,
+          fps: @fps,
+          sample_rate: payload.fetch("metadata").fetch("sample_rate")
+        }
+      end
+
+      private
+
+      def record
+        validate_audio_file!
+        input = Vizcore::Audio::FileInput.new(path: @audio_file.to_s)
+        raise ArgumentError, input.last_error.message if input.last_error
+
+        input.start
+        sample_rate = input.stream_sample_rate
+        capture_size = capture_size_for(sample_rate)
+        pipeline = build_pipeline(sample_rate)
+        features = @frames.times.map do |index|
+          {
+            "index" => index,
+            "time" => (index / @fps).round(6),
+            "audio" => serializable(pipeline.call(input.read(capture_size)))
+          }
+        end
+        payload(sample_rate: sample_rate, capture_size: capture_size, features: features)
+      ensure
+        input&.stop
+      end
+
+      def payload(sample_rate:, capture_size:, features:)
+        {
+          "version" => VERSION,
+          "metadata" => {
+            "audio_file" => @audio_file.to_s,
+            "frames" => @frames,
+            "fps" => @fps,
+            "sample_rate" => sample_rate,
+            "capture_size" => capture_size,
+            "noise_gate" => @noise_gate,
+            "bpm" => @bpm,
+            "bpm_lock" => @bpm_lock,
+            "audio_normalize" => serializable(@audio_normalize)
+          },
+          "features" => features
+        }
+      end
+
+      def build_pipeline(sample_rate)
+        Pipeline.new(
+          sample_rate: sample_rate,
+          fft_size: supported_fft_size(Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE),
+          noise_gate: @noise_gate,
+          audio_normalize: @audio_normalize,
+          bpm: @bpm,
+          bpm_lock: @bpm_lock
+        )
+      end
+
+      def validate_audio_file!
+        raise ArgumentError, "Audio file not found: #{@audio_file}" unless @audio_file.file?
+        return if Vizcore::Audio::FileInput::SUPPORTED_EXTENSIONS.include?(@audio_file.extname.downcase)
+
+        raise ArgumentError, "Unsupported audio format: #{@audio_file.extname.downcase}"
+      end
+
+      def capture_size_for(sample_rate)
+        [(sample_rate.to_f / @fps).round, 1].max
+      end
+
+      def supported_fft_size(size)
+        value = Integer(size)
+        return value if value.positive? && (value & (value - 1)).zero?
+
+        Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE
+      rescue StandardError
+        Vizcore::Audio::InputManager::DEFAULT_FRAME_SIZE
+      end
+
+      def serializable(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), output|
+            output[key.to_s] = serializable(entry)
+          end
+        when Array
+          value.map { |entry| serializable(entry) }
+        when Float
+          value.finite? ? value.round(6) : 0.0
+        when Symbol
+          value.to_s
+        else
+          value
+        end
+      end
+
+      def normalize_frame_count(value)
+        count = Integer(value)
+        raise ArgumentError, "frames must be positive" unless count.positive?
+
+        count
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "frames must be a positive integer"
+      end
+
+      def normalize_frame_rate(value)
+        rate = Float(value)
+        raise ArgumentError, "fps must be positive" unless rate.positive?
+
+        rate
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "fps must be a positive number"
+      end
+    end
+  end
+end

data/lib/vizcore/analysis/feature_replay.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require_relative "feature_recorder"
+
+module Vizcore
+  module Analysis
+    # Replays recorded analysis features as a pipeline-compatible source.
+    class FeatureReplay
+      attr_reader :metadata
+
+      def initialize(path:)
+        @path = Pathname.new(path.to_s).expand_path
+        payload = load_payload
+        @metadata = deep_symbolize(payload.fetch("metadata", {}))
+        @features = load_features(payload)
+        @cursor = 0
+      end
+
+      # @param _samples [Array<Float>, nil] ignored; replay data already contains analyzed features
+      # @return [Hash<Symbol, Object>] recorded audio analysis for the next frame
+      def call(_samples = nil)
+        audio = @features.fetch(@cursor)
+        @cursor = (@cursor + 1) % @features.length
+        deep_dup(audio)
+      end
+
+      def frame_count
+        @features.length
+      end
+
+      private
+
+      def load_payload
+        raise ArgumentError, "Feature file not found: #{@path}" unless @path.file?
+
+        payload = JSON.parse(@path.read)
+        version = payload["version"]
+        return payload if version == FeatureRecorder::VERSION
+
+        raise ArgumentError, "Unsupported feature file version: #{version.inspect}"
+      rescue JSON::ParserError => e
+        raise ArgumentError, "Invalid feature file JSON: #{e.message}"
+      end
+
+      def load_features(payload)
+        features = Array(payload["features"]).map.with_index do |entry, index|
+          audio = Hash(entry).fetch("audio", nil)
+          raise ArgumentError, "Feature frame #{index} is missing audio data" unless audio.is_a?(Hash)
+
+          deep_symbolize(audio)
+        end
+        raise ArgumentError, "Feature file contains no frames" if features.empty?
+
+        features
+      end
+
+      def deep_symbolize(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), output|
+            output[key.to_s.to_sym] = deep_symbolize(entry)
+          end
+        when Array
+          value.map { |entry| deep_symbolize(entry) }
+        else
+          value
+        end
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, entry), output| output[key] = deep_dup(entry) }
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end