design_ir.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/design_line_metrics.hpp>
 
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <optional>
#include <map>
#include <unordered_map>
#include <variant>
 
namespace pulp::view {
 
// ── Design source types ─────────────────────────────────────────────────
//
// DesignSource is part of the IR model: DesignIR::source is a DesignSource
// by value, so the enum must be defined here (foundational) to keep the
// header dependency graph acyclic. The string<->enum helper functions live
// in design_sources.hpp alongside the source adapters.
 
enum class DesignSource {
    figma,
    stitch,
    v0,
    pencil,
    claude,   // Anthropic Claude Design — manual HTML/zip export, no Anthropic API
    designmd, // Google DESIGN.md (Apache-2.0) — YAML frontmatter + Markdown body
    jsx,      // Single-file React JSX instrument — compiled via esbuild + bundled React/ReactDOM
    figma_plugin,    // Pulp's "Design for Pulp" Figma plugin export envelope
    html,            // Generic runnable HTML evaluated by the isolated browser lane
    preconverted_svg // Validated SVG + control-map sidecar; no source conversion
};
 
// ── Normalized Intermediate Representation ──────────────────────────────

enum class LayoutDirection { row, column };

enum class LayoutAlign {
    flex_start, flex_end, center, stretch, space_between, space_around
};

enum class SizingMode { fixed, hug, fill };

struct IRBoxShadow {
    float offset_x = 0.0f;
    float offset_y = 0.0f;
    float blur = 0.0f;
    float spread = 0.0f;
    std::string color;            
    bool inset = false;
    std::string raw;              
};

struct IRStyle {
    std::optional<std::string> background_color;
    std::optional<std::string> background_gradient;   // linear-gradient(...)
    std::optional<std::string> background_image;      // url(...), data:..., or none
    std::optional<std::string> background_repeat;
    std::optional<std::string> background_position;
    // CSS background-size keyword ("cover", "contain", "auto"). Figma IMAGE
    // fill scale modes lower here on frame-shaped nodes (FILL → cover,
    // FIT → contain, TILE → auto + background_repeat: repeat). Stored on the
    // View via set_background_size and emitted by every codegen; raster
    // background-image paint honoring is the same deferred slot as
    // background_repeat (View::style_extras).
    std::optional<std::string> background_size;
    // CSS background-origin ("padding-box", "border-box", "content-box"),
    // possibly a per-layer list. It decides the box a repeating background
    // tile is sized and positioned in; absent means the CSS initial value,
    // padding-box.
    std::optional<std::string> background_origin;
    // CSS object-fit for image-shaped nodes ("fill", "contain", "cover",
    // "none", "scale-down"). Figma IMAGE fill scale modes lower here when the
    // fill becomes a dedicated image node (FILL → cover, FIT → contain);
    // ImageView::paint honors it, so this is a rendered property, not a
    // storage-only slot.
    std::optional<std::string> object_fit;
    std::optional<std::string> color;                  // text color
    std::optional<float> opacity;
    // CSS mix-blend-mode keyword (e.g. "multiply", "screen", "color-dodge").
    // Normalized to the lowercase-hyphen CSS spelling at parse time; the
    // engine's View::set_mix_blend_mode + setMixBlendMode bridge consume it.
    std::optional<std::string> mix_blend_mode;
    std::optional<float> border_radius;
    std::optional<std::string> border;                 // e.g. "1px solid #333"
    std::optional<std::string> border_color;
    std::optional<float> border_width;
    std::optional<std::string> border_style;
    std::optional<std::string> border_top_color;
    std::optional<std::string> border_right_color;
    std::optional<std::string> border_bottom_color;
    std::optional<std::string> border_left_color;
    std::optional<float> border_top_width;
    std::optional<float> border_right_width;
    std::optional<float> border_bottom_width;
    std::optional<float> border_left_width;
    std::optional<float> border_top_left_radius;
    std::optional<float> border_top_right_radius;
    std::optional<float> border_bottom_right_radius;
    std::optional<float> border_bottom_left_radius;
    std::vector<IRBoxShadow> box_shadow;               // ordered CSS shadow layers
    std::optional<std::string> filter;                 // e.g. "blur(4px)"
    std::optional<std::string> backdrop_filter;
    // CSS clip-path / mask. The engine (View::set_clip_path / set_mask /
    // set_mask_image / set_mask_size) + the setClipPath/setMask* bridge
    // consume these; sources that carry them — and Figma mask
    // layers once the extractor emits a clip-path — survive the IR.
    std::optional<std::string> clip_path;
    // The clip an importer resolved for THIS node, in the node's own
    // coordinate space (origin at its top-left, same space as `clip_path`).
    //
    // Carried per node rather than inherited from a clipping parent, because
    // CSS clips along the containing-block chain while a tree clips by
    // parentage, and the two disagree in both directions: an absolutely
    // positioned node can escape an `overflow: hidden` ancestor it sits inside,
    // and a node moved to a new parent must keep the clip its old one gave it.
    // A rectangle attached to the node travels with the node, so re-parenting
    // cannot change what it clips. The engine (View::set_ancestor_clip_rect)
    // applies it to the node's OWN ink only — every descendant carries its own.
    //
    // The corner radii belong to the clip, not to the node: CSS clips overflow
    // to the clipper's ROUNDED padding box, so a square-cornered child inside a
    // rounded card is cut to the card's curve. Without them a rounded card whose
    // media area is a plain rectangle paints that rectangle square into the
    // corner, and the card reads as unrounded even though its own border curves.
    // A radius applies only where the clip's corner is still the clipper's own —
    // a corner cut by a second, tighter clipper is square, so the resolver drops
    // the radius there rather than rounding a corner nothing rounded.
    struct ClipRect {
        float x = 0, y = 0, width = 0, height = 0;
        float radius_tl = 0, radius_tr = 0, radius_br = 0, radius_bl = 0;
    };
    std::optional<ClipRect> clip_rect;
    std::optional<std::string> mask;                   // `mask` shorthand
    std::optional<std::string> mask_image;
    std::optional<std::string> mask_size;
    std::optional<std::string> font_family;
    std::optional<float> font_size;
    std::optional<int> font_weight;
    std::optional<std::string> font_style;             // normal, italic
    std::optional<std::string> text_align;
    // Vertical alignment of text within its design-reserved slot: "top",
    // "middle", "bottom" (Figma textAlignVertical, normalized). When set it is
    // design authority: codegen honors it instead of the tall-slot centering
    // heuristic (which remains the fallback for sources that never say).
    std::optional<std::string> vertical_align;
    std::optional<float> letter_spacing;
    std::optional<float> line_height;
    std::optional<std::string> text_transform;
    std::optional<std::string> text_decoration;
    std::optional<std::string> white_space;
    std::optional<std::string> text_overflow;
    std::optional<std::string> overflow;               // hidden, scroll, auto
    std::optional<std::string> cursor;
    std::optional<std::string> pointer_events;         // auto, none
    std::optional<std::string> position;               // absolute, relative
    std::optional<float> top, left, right, bottom;
    std::optional<int> z_index;
    std::optional<std::string> transform;              // rotate, scale, etc.
    std::optional<float> width, height;
    std::optional<float> min_width, min_height;
    std::optional<float> max_width, max_height;
    // The asset's true visual extent in logical px when it bleeds past the
    // layout box (figma-plugin `render_bounds`: drop shadows, glow, oversized
    // chrome like the silver-knob graphic). w/h = rendered size, dx/dy = offset
    // of the render origin relative to the layout box (negative = extends
    // left/up). When present + larger than width/height, the importer sizes the
    // image to render_bounds and offsets by dx/dy instead of squashing it.
    struct RenderBounds { float w = 0, h = 0, dx = 0, dy = 0; };
    std::optional<RenderBounds> render_bounds;
};

struct IRLayout {
    std::optional<std::string> display;  // flex, grid, none
    LayoutDirection direction = LayoutDirection::column;
    float gap = 0.0f;
    std::optional<float> row_gap;
    std::optional<float> column_gap;
    float padding_top = 0.0f;
    float padding_right = 0.0f;
    float padding_bottom = 0.0f;
    float padding_left = 0.0f;
    std::optional<float> margin_top;
    std::optional<float> margin_right;
    std::optional<float> margin_bottom;
    std::optional<float> margin_left;
    LayoutAlign justify = LayoutAlign::flex_start;
    LayoutAlign align = LayoutAlign::stretch;
    std::optional<std::string> align_self;
    std::optional<std::string> align_content;
    bool wrap = false;
    std::optional<float> flex_grow;
    std::optional<float> flex_shrink;
    std::optional<std::string> flex_basis;
    std::optional<int> order;
    std::optional<float> aspect_ratio;
    std::optional<std::string> overflow_x;
    std::optional<std::string> overflow_y;
    SizingMode width_mode = SizingMode::fixed;
    SizingMode height_mode = SizingMode::fixed;
    // Figma-style resize CONSTRAINTS, normalized to a small token set and mapped
    // onto flex/position at codegen (margin:auto / flex-grow / align-self), never
    // a new layout primitive. Horizontal: left | right | center | scale |
    // stretch (pin both edges). Vertical: top | bottom | center | scale |
    // stretch. Empty = unconstrained (the flex default, anchored start).
    std::optional<std::string> h_constraint;
    std::optional<std::string> v_constraint;
    // CSS Grid. Pulp's engine has a native grid layout (LayoutMode::grid via the
    // createGrid/setGrid bridge); design-import lowers a grid container here
    // instead of flattening it to flex. Container tracks are raw CSS track lists
    // ("1fr 1fr", "100px auto"); auto_flow is "row"/"column"(+ " dense").
    // grid_column/grid_row are per-item placements ("1 / 3", "2"); span/named
    // lines are deferred (left to the flex fallback). display=="grid" OR a
    // template present is the grid signal.
    std::optional<std::string> grid_template_columns;
    std::optional<std::string> grid_template_rows;
    std::optional<std::string> grid_auto_flow;
    std::optional<std::string> grid_column;   // item placement (column line/span)
    std::optional<std::string> grid_row;      // item placement (row line/span)
};

enum class AudioWidgetType {
    none,       // Not an audio widget
    knob,
    fader,
    meter,
    xy_pad,
    waveform,
    spectrum,
    // An on/off. It is a member of THIS enum rather than a node type because
    // this enum is what both consumers of a lowered control key off: the native
    // materializer reaches its widget kind through kind_from_audio(), and the
    // script emitter reaches its factory and its parameter binding through
    // widget_type_name(). A toggle expressed any other way binds on one path
    // and renders inert on the other.
    toggle,
    // A choice between named alternatives, drawn as ONE control: a shared
    // track with N labelled segments and exactly one lit. Not N adjacent
    // toggles — a row of independent switches can show two lit at once and
    // reads as several controls that happen to touch.
    selector,
    // A count the player reads as a number — voices, octaves, retrigger. A
    // knob can carry one, and reads badly doing it: the value that matters is
    // the integer, and a dial asks the eye to infer it from an angle.
    stepper
};

inline float selector_segment_value(int index, int count) {
    if (count <= 1) return 0.0f;
    const int clamped = index < 0 ? 0 : (index >= count ? count - 1 : index);
    return static_cast<float>(clamped) / static_cast<float>(count - 1);
}

inline float stepper_normalized_value(double plain, double min, double max) {
    if (max <= min) return 0.0f;
    const double span = max - min;
    const double clamped = plain < min ? min : (plain > max ? max : plain);
    return static_cast<float>((clamped - min) / span);
}
 
inline double stepper_plain_value(float normalized, double min, double max,
                                  double step) {
    if (max <= min) return min;
    const double raw = min + static_cast<double>(normalized) * (max - min);
    if (step <= 0.0) return raw;
    // Snap to the step GRID measured from `min`, so a range that does not start
    // at zero still lands on the values the author declared.
    const double snapped = min + std::round((raw - min) / step) * step;
    return snapped < min ? min : (snapped > max ? max : snapped);
}
 
inline int selector_segment_index(float value, int count) {
    if (count <= 1) return 0;
    if (!std::isfinite(value)) return 0;
    const float scaled = value * static_cast<float>(count - 1);
    const int nearest = static_cast<int>(scaled + 0.5f);
    return nearest < 0 ? 0 : (nearest >= count ? count - 1 : nearest);
}

inline bool toggle_on_from_normalized(double value) {
    return std::isfinite(value) && value >= 0.5;
}
 
struct IRNode;

enum class WidgetPromotionSignal {
    none,
    onclick_attribute,
    aria_role_button,
    cursor_pointer
};
 
// ── Additive identity fields on IRNode ────────────────────────────────────
// The TS-side @pulp/import-ir package already defines the canonical shape.
// These fields are deliberately additive; IRStyle/IRLayout migration to
// TS-style paint/text/layout is tracked separately.
//
// stable_anchor_id is the key the tweaks layer (pulp-tweaks.json) uses to
// match user edits back to nodes across re-imports. Computed by the
// anchor strategies in <pulp/view/anchor_strategy.hpp> (mirror of
// packages/pulp-import-ir/src/anchors.ts).
//
// provenance + confidence let the inspector (and downstream tooling) know
// where a node came from and how confident the adapter was — critical
// for surfacing "this was sampled from an image, not a literal" in the
// future Lock-to-source UI.

enum class IRConfidence {
    pass,        // Adapter fully understood the source node
    diverge,     // Adapter produced something close-but-not-equivalent
    not_impl     // Adapter does not know how to lower this node yet
};

struct IRProvenance {
    std::string adapter;     // e.g. "figma", "stitch-html", "claude-design-html"
    std::string version;     // adapter version string ("1.0.0" or schema rev)
    std::string source_uri;  // source identifier (file path, URL, MCP handle)
};

struct IRTextLineBox {
    float left = 0.0f;
    float top = 0.0f;
    float width = 0.0f;
    float height = 0.0f;
    int start = 0;
    int length = 0;
};

struct IRTextLayoutBasis {
    float width = 0.0f;
    std::string resolved_face;
    std::optional<LineMetrics> line_metrics;
};
 
struct IRTextRun {
    int start = 0;
    int end = 0;
    std::optional<float> font_size;
    std::optional<int> font_weight;
    std::optional<std::string> font_family;
    std::optional<std::string> font_style;       // "italic" / "oblique ..." / "normal"
    std::optional<std::string> color;
    std::optional<float> letter_spacing;
    std::optional<std::string> text_decoration;  // "underline" / "line-through"
};

// ── Faithful-vector import (Plan B) ──────────────────────────────────────────
// How a node should be rendered. `normal` is the existing widget/sprite
// materialization. `faithful_svg` means: render this node's own SVG export
// (svg_asset_id) pixel-faithfully via DesignFrameView, and overlay native
// interaction from `interactive_elements` (source-side semantics — NOT guessed
// from the SVG). `faithful_capture` is the browser-evaluated HTML lane: render
// the captured raster named by capture_asset_id while separately carrying the
// browser's evidence-ranked semantic report. Keeping it distinct from a normal
// image makes the fidelity/interaction boundary explicit and prevents a
// screenshot-backed import from masquerading as a fully-native reconstruction.
// Per-node so faithful-vector, browser-capture, and native nodes can coexist.
enum class NodeRenderMode {
    normal,
    faithful_svg,
    faithful_capture,
};
 
// The kind of an interactive overlay on a faithful_svg node. Deliberately
// separate from AudioWidgetType (which is audio-parameter specific); this models
// design-interaction semantics.
//
// Two materialization mechanisms (see DesignFrameView):
//   - `knob` is SVG-PATCH: its needle path is rotated in the SVG and re-rendered
//     (pixel-perfect, uses cx/cy/hit_radius/svg_patch_d/default_value).
//   - `fader` is SVG-PATCH like `knob` but TRANSLATES its thumb (svg_patch_d) by
//     value along the track box [x,y,w,h] (orientation follows the track shape).
//   - `toggle` is a click-to-flip control over the box [x,y,w,h]; with
//     svg_patch_d set it is a SWITCH whose moving dot is that path.
//   - `dropdown` / `text_field` / `tab_group` / `stepper` are NATIVE-OVERLAY: an
//     opaque child widget (ComboBox / TextEditor / tab group / < > stepper) is
//     positioned over the element's `rect` and replaces that baked SVG region
//     with a live control.
// Every value here maps 1:1 to a DesignFrameElement::Kind in to_frame_elements()
// (design_import_native_common.cpp); the runtime already backs all of them.
enum class InteractiveElementKind {
    knob,
    fader,
    toggle,
    dropdown,
    text_field,
    tab_group,
    // A `< >` stepper: a header value cycled by prev/next chevrons (the design's
    // section-header preset selectors — named "Dropdown" but carrying a `< >`
    // pair, not a down-chevron). Uses `options` + `selected_index` like a
    // dropdown, but steps through them in place instead of opening a popup.
    stepper,
    // `swap` is a swap-link button: clicking its rect activates `target_frame`
    // (a mode/page switch the design wires up).
    swap,
    // `action` is a command button: clicking its rect fires the named `action`
    // (e.g. "octave_up") — the consumer maps the id to its own state. It does not
    // light, emit notes, or swap frames.
    action,
    // `xy_pad` is SVG-patch like `fader` but 2D: dragging in its rect [x,y,w,h]
    // moves the puck (svg_patch_d). `default_value` is the X (0→left, 1→right),
    // `default_value_y` the Y (0→top, 1→bottom).
    xy_pad,
    // `value_label` is a live read-only text overlay painted over its rect (the
    // design's baked readout). `text` is the initial string; `value_left_align`
    // left-aligns it (for a "LABEL <value>" readout that grows rightward).
    value_label,
    // `custom` is a registered native control: the materializer maps
    // it to DesignFrameElement::Kind::custom, whose overlay is built by the
    // factory registered under `factory_id` (+ opaque `custom_props`). Unmapped
    // factory → inert render + an import diagnostic (never a silent knob).
    custom,
};
 
// One source-identified interactive element overlaid on a faithful_svg render.
// Coordinates are in the SVG's own space. The importer fills this from the
// source (Figma node ids/names/properties), so behavior is real, not inferred.
struct IRInteractiveElement {
    InteractiveElementKind kind = InteractiveElementKind::knob;
 
    // ── knob (SVG-patch) ────────────────────────────────────────────────
    float cx = 0.0f;                 
    float cy = 0.0f;
    float hit_radius = 0.0f;         
    std::string svg_patch_d;
    float default_value = 0.5f;      

    bool flash = false;
 
    // ── overlay controls (dropdown / text_field / tab_group) ─────────────
    float x = 0.0f;
    float y = 0.0f;
    float w = 0.0f;
    float h = 0.0f;
    std::vector<std::string> options;
    int selected_index = 0;
    std::string placeholder;
    std::string bg_color;
 
    // ── swap / action / xy_pad / value_label ─────────────────────────────
    int target_frame = -1;
    std::string action;
    std::string text;
    bool value_left_align = false;
    float default_value_y = 0.5f;

    std::string label;

    std::string param_key;
 
    // ── Import report (resolution provenance) ────────────────────────────
    // Carried from the importer (where all three signals — geometry/affordance,
    // name/token, component identity — exist) THROUGH to the host materialize
    // boundary, so a low-confidence or conflicted control is SEEN ("this might be
    // wrong") instead of discovered in the DAW. The resolution LOGIC that fills
    // these lives in the importer; this struct carries it to materialization.
    int resolution_rung = 0;
    float confidence_score = 1.0f;
    std::vector<std::string> conflict_signals;
    bool verification_pass = true;
 
    // ── custom (registered control) ──────────────────────────────────────
    std::string factory_id;
    std::string custom_props;

    std::optional<std::string> source_node_id;
};
 
struct IRNode {
    std::string type;   // "frame", "text", "image", "button", "input", "slider"
    std::string name;
    std::string text_content;            // For text nodes
    std::vector<IRTextRun> text_runs;    // Per-range style overrides (mixed text)
    std::vector<IRTextLineBox> text_line_boxes;
    std::optional<IRTextLayoutBasis> text_layout_basis;
    IRStyle style;
    IRLayout layout;
    AudioWidgetType audio_widget = AudioWidgetType::none;
    std::string audio_label;             // Label for audio widgets (e.g. "Gain")
    float audio_min = 0.0f;
    float audio_max = 1.0f;
    float audio_default = 0.5f;
    // True when the source explicitly carried a min/max range (vs the 0..1
    // defaults). Lets the codegen reconstruct the value/range display stack only
    // for widgets that actually declared a range.
    bool has_audio_range = false;
    std::vector<IRNode> children;
    std::unordered_map<std::string, std::string> attributes;  // Extra metadata
 
    // ── Additive identity fields ─────────────────────────────────────────
    std::optional<std::string> stable_anchor_id;
    std::optional<std::string> anchor_strategy;
    std::optional<std::string> source_node_id;
    std::optional<std::string> source_adapter;
    std::optional<std::string> source_version;
    std::optional<IRProvenance> provenance;
    std::optional<IRConfidence> confidence;
    std::optional<std::string> raw_source;
 
    // ── Faithful-vector import ───────────────────────────────────────────
    NodeRenderMode render_mode = NodeRenderMode::normal;
    std::optional<std::string> svg_asset_id;
    std::optional<std::string> capture_asset_id;
    std::vector<IRInteractiveElement> interactive_elements;
    std::vector<IRNode> alternate_frames;
};
 
enum class ImportDiagnosticSeverity {
    info,
    warning,
    error
};
 
enum class ImportDiagnosticKind {
    unknown,
    unsupported_property,
    unsupported_node,
    unresolved_asset,
    snapshot_semantics_warning,
    legacy_field_shortcut,
    capture_partial,
    fallback_used
};
 
struct ImportDiagnostic {
    ImportDiagnosticSeverity severity = ImportDiagnosticSeverity::warning;
    std::string code;
    std::string path;
    std::string message;
    ImportDiagnosticKind kind = ImportDiagnosticKind::unknown;
    std::optional<std::string> anchor_id;
    std::optional<std::string> property;
};
 
struct IRAssetRef {
    std::string asset_id;       // stable handle used by nodes
    std::string original_uri;   // as authored
    std::vector<std::string> original_uri_aliases; // equivalent authored refs
    std::optional<std::string> local_path;
    std::string content_hash;   // sha256 of resolved bytes; empty if unresolved
    std::string mime;
    std::optional<int> width;
    std::optional<int> height;
    std::optional<std::string> font_family;
    std::optional<std::string> license;
    std::optional<std::string> source_url;
    std::vector<ImportDiagnostic> diagnostics;
};
 
struct IRAssetManifest {
    std::vector<IRAssetRef> assets;
    int version = 1;
 
    const IRAssetRef* resolve(std::string_view asset_id) const {
        if (asset_id.empty())
            return nullptr;
        for (const auto& asset : assets) {
            if (asset.asset_id == asset_id)
                return &asset;
        }
        return nullptr;
    }
};

struct IRFontAsset {
    std::string family;          // CSS family name nodes reference via font_family
    std::string style;           // "Regular", "Italic", … (informational)
    int weight = 400;            // 100–900; the lower bound of a weight range
    std::string asset_id;        // → asset_manifest entry holding the .ttf/.otf/.woff2
    std::string resolved_path;   // absolute fs path, stamped by the CLI asset-resolution pass
    std::string font_style;      // CSS font-style descriptor; empty when not captured
    int weight_max = 0;          // upper bound of a font-weight range; 0 for one weight
    std::string unicode_range;   // CSS unicode-range descriptor, verbatim; empty = every code point
};
 
struct IRTokenIdentity {
    std::string source_id;
    std::string source_collection;
    std::string source_mode;
    std::string source_adapter;
};

struct IRTokens {
    std::unordered_map<std::string, std::string> colors;       // name → "#hex"
    std::unordered_map<std::string, float> dimensions;         // name → px value
    std::unordered_map<std::string, std::string> strings;      // name → string
    // Keyed by canonical token path (for example "colors.primary").
    std::unordered_map<std::string, IRTokenIdentity> source_identity;
};

struct DesignIR {
    int version = 1;
    IRNode root;
    IRTokens tokens;
    IRAssetManifest asset_manifest;
    std::vector<IRFontAsset> font_family_assets;   // bundled fonts (#43a/#43b)
    std::vector<ImportDiagnostic> diagnostics;
    DesignSource source = DesignSource::figma;
    std::string source_file;
    std::string capture_method;
    int settle_rounds = 0;
    std::string fallback_reason;
    std::string source_adapter;
    std::string source_version;
    std::string imported_at;
};
 
struct DesignIrJsonOptions {
    int version = 0; // 0 preserves DesignIR::version
    bool include_tokens = true;
    bool include_source_metadata = true;
    bool include_asset_manifest = true;
};
 
struct DesignIrAssetOptions {
    bool allow_network_fetch = false;
    int network_timeout_ms = 30000;
    std::filesystem::path cache_directory;
    std::filesystem::path base_directory;
    std::string base_url;
    std::unordered_map<std::string, std::string> expected_hash_by_uri;
};
 
} // namespace pulp::view