screengraft 0.13.1

package/scripts/warp.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""
+screengraft — M0: manual four-point perspective warp.
+
+Takes a photo of a device and a UI screenshot, and warps the screenshot into
+a given quadrilateral (the four screen corners in the photo) so the
+perspective matches exactly. Geometry, not generation: a single
+cv2.getPerspectiveTransform + cv2.warpPerspective call, deterministic
+end to end.
+
+Design constraints this script exists to satisfy (see the project's design notes):
+  - Warp once, at the photo's full resolution — never warp-then-scale
+    (double resampling blurs text).
+  - Fully deterministic: same inputs -> byte-identical output PNG.
+  - No AI, no guessing: corners are supplied by the caller (a human, via the
+    drag-picker UI, or hardcoded for a test) — this script only does the
+    textbook part.
+
+Usage:
+  python3 warp.py --photo photo.jpg --screenshot ui.png \
+      --corners '[[120,80],[860,140],[840,900],[100,840]]' \
+      --output out.png [--corner-radius 40]
+
+Corners are [x, y] pixel coordinates in the PHOTO, in order
+TL, TR, BR, BL (top-left, top-right, bottom-right, bottom-left of the
+screen as it appears in the photo — order matters, it defines the mapping).
+"""
+
+import argparse
+import json
+import sys
+
+import cv2
+import numpy as np
+
+import grade as _grade   # M2: the realism pass
+
+
+MASK_SS = 4   # destination-space supersampling for the screen's edge
+
+
+def rounded_mask(w: int, h: int, radius: float) -> np.ndarray:
+    """White-on-black mask, full frame minus rounded corners cut to black.
+
+    Computed analytically rather than drawn, for two reasons.
+
+    Geometry. The screenshot occupies the edge-coordinate box [0,w]x[0,h] --
+    the box `compose` hands to getPerspectiveTransform -- so pixel *centres*
+    sit at i+0.5 and the four arc centres belong at (r, r) and (w-r, h-r) in
+    that same edge space. The previous version drew the arcs with cv2.circle,
+    whose integer coordinates are pixel *centres*, which placed the whole
+    rounded rectangle half a pixel down and to the right. The top and left
+    arcs still came out tangent to the frame, but the bottom and right arcs
+    were tangent to y=h and x=w -- one row/column outside the image -- so each
+    was clipped a pixel early and met its straight edge at a slope
+    discontinuity instead of flattening into it. Reported from a real save, 4 Sep 2026
+    as the bottom corners looking "cut out by a pixel or two"; the row
+    coverage profile confirmed it, the bottom being exactly the top shifted
+    by one row (the tangent row missing entirely).
+
+    Antialiasing. Coverage is a 1px linear ramp on the distance to the
+    rounded rectangle, symmetric on all four sides by construction. LINE_AA's
+    own ramp is not, and cannot be nudged sub-pixel without the fixed-point
+    `shift` dance.
+    """
+    if radius <= 0:
+        return np.full((h, w), 255, dtype=np.uint8)
+    r = float(max(0.0, min(float(radius), w / 2.0, h / 2.0)))
+    xs = np.arange(w, dtype=np.float64) + 0.5      # pixel centres, edge coords
+    ys = np.arange(h, dtype=np.float64) + 0.5
+    # Per-axis distance past the arc-centre rail: zero everywhere except the
+    # four corner squares, so `dist` is the true distance to the rounded
+    # rectangle's boundary there and the straight edges stay exactly full.
+    dx = np.maximum(np.maximum(r - xs, xs - (w - r)), 0.0)
+    dy = np.maximum(np.maximum(r - ys, ys - (h - r)), 0.0)
+    dist = np.hypot(dx[None, :], dy[:, None])
+    coverage = np.clip(r + 0.5 - dist, 0.0, 1.0)
+    return np.rint(coverage * 255.0).astype(np.uint8)
+
+
+def _warp_mask_antialiased(src_mask, H, pw, ph, dst_quad):
+    """Warp the screen mask into photo space with coverage antialiasing.
+
+    A single warpPerspective of a binary mask gives a ~1px hard transition,
+    so the screen's edge lands on the photo stepped — obvious on a slanted
+    edge, which is every interesting photo (reported 4 Sep 2026).
+
+    Instead the mask is rasterised at MASK_SS x the output scale and then
+    INTER_AREA'd down, so each output pixel gets the *fraction* of itself the
+    screen actually covers — the same thing multisampling does. Only the
+    quad's bounding box is supersampled, so the cost is a few megapixels
+    rather than MASK_SS^2 x the whole photo.
+    """
+    x0 = max(0, int(np.floor(dst_quad[:, 0].min())) - 2)
+    y0 = max(0, int(np.floor(dst_quad[:, 1].min())) - 2)
+    x1 = min(pw, int(np.ceil(dst_quad[:, 0].max())) + 2)
+    y1 = min(ph, int(np.ceil(dst_quad[:, 1].max())) + 2)
+    out = np.zeros((ph, pw), dtype=np.uint8)
+    if x1 <= x0 or y1 <= y0:
+        return out
+    bw, bh = x1 - x0, y1 - y0
+    # photo space -> supersampled bbox-local space
+    T = np.array([[MASK_SS, 0, -MASK_SS * x0],
+                  [0, MASK_SS, -MASK_SS * y0],
+                  [0, 0, 1]], dtype=np.float64)
+    big = cv2.warpPerspective(
+        src_mask, T @ H, (bw * MASK_SS, bh * MASK_SS),
+        flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+    out[y0:y1, x0:x1] = cv2.resize(big, (bw, bh), interpolation=cv2.INTER_AREA)
+    return out
+
+
+def shoelace_area(pts: np.ndarray) -> float:
+    x = pts[:, 0]
+    y = pts[:, 1]
+    return 0.5 * abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
+
+
+def compose(photo: np.ndarray, screenshot: np.ndarray, corners, corner_radius: float = 0.0,
+            grade: float = 0.0, grain: bool = False, screen_off: np.ndarray = None,
+            specular: float = 0.75) -> np.ndarray:
+    """Warp `screenshot` into the quad `corners` (TL,TR,BR,BL, photo pixels) on `photo`.
+
+    Single resampling pass at the photo's resolution; deterministic. This is the
+    whole engine — the CLI below and ui.py both call it.
+    """
+    dst_quad = np.array(corners, dtype=np.float32)
+    if shoelace_area(dst_quad) < 1.0:
+        raise ValueError("degenerate quad (near-zero area) — check corner order TL,TR,BR,BL")
+
+    # --- prefilter for minification -------------------------------------
+    # A UI screenshot is almost always far larger than the screen it lands
+    # on: 1206x2622 into a 226x454 quad is 5.3x across and 5.8x along, so
+    # each output pixel is the average of ~31 source pixels. warpPerspective
+    # (like remap) does NOT area-average — INTER_LANCZOS4 samples a fixed 8x8
+    # window around one source point no matter the scale, and Lanczos is a
+    # sharpening kernel, so heavy minification came out aliased and crunchy
+    # with text turned to noise (3 Sep 2026, reported from a real save).
+    #
+    # The fix is the mipmap principle: area-average DOWN to roughly the
+    # destination footprint first, then warp at ~1:1. This is not the
+    # "warp-then-scale" the build brief warns against — that's resampling an
+    # already-warped result, which blurs. This is resampling the source with
+    # the right filter before the only geometric pass, which is how you avoid
+    # aliasing when minifying.
+    top = float(np.linalg.norm(dst_quad[1] - dst_quad[0]))
+    bottom = float(np.linalg.norm(dst_quad[2] - dst_quad[3]))
+    left = float(np.linalg.norm(dst_quad[3] - dst_quad[0]))
+    right = float(np.linalg.norm(dst_quad[2] - dst_quad[1]))
+    # Use the LONGER opposing edge of each pair: under perspective the near
+    # edge carries the most detail, and that's the resolution to preserve.
+    need_w = max(top, bottom)
+    need_h = max(left, right)
+    sh0, sw0 = screenshot.shape[:2]
+    scale_x, scale_y = need_w / sw0, need_h / sh0
+    if 0 < max(scale_x, scale_y) < 0.95:          # only ever downsample
+        new_w = max(1, int(round(sw0 * max(scale_x, scale_y))))
+        new_h = max(1, int(round(sh0 * max(scale_x, scale_y))))
+        screenshot = cv2.resize(screenshot, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        corner_radius = corner_radius * (new_w / sw0)   # radius is in source px
+    # --------------------------------------------------------------------
+
+    sh, sw = screenshot.shape[:2]
+    src_rect = np.array([[0, 0], [sw, 0], [sw, sh], [0, sh]], dtype=np.float32)
+    H = cv2.getPerspectiveTransform(src_rect, dst_quad)
+    ph, pw = photo.shape[:2]
+    # Radius stays fractional: rounded_mask is analytic, and after the
+    # prefilter rescale above a truncation here is up to a whole pixel of
+    # radius thrown away at exactly the scale the viewer is looking at.
+    src_mask = rounded_mask(sw, sh, float(corner_radius))
+    # BORDER_REPLICATE, not BORDER_CONSTANT black: with an antialiased mask
+    # the edge pixels are a genuine blend of screen and photo, and sampling
+    # black just outside the screenshot would draw a dark fringe right where
+    # the antialiasing is supposed to be doing its work. Replicating the edge
+    # pixel means a half-covered pixel blends real screen colour instead.
+    warped_screen = cv2.warpPerspective(
+        screenshot, H, (pw, ph), flags=cv2.INTER_LANCZOS4,
+        borderMode=cv2.BORDER_REPLICATE)
+    warped_mask = _warp_mask_antialiased(src_mask, H, pw, ph, dst_quad)
+
+    # --- M2: the realism pass -------------------------------------------
+    # Order is not arbitrary. The light match runs on the warped screen BEFORE
+    # compositing, so it measures and moves only screen pixels — grading after
+    # the blend would drag the bezel with it. Grain and the specular lift run
+    # AFTER, because both are things that happen to the finished surface, and
+    # both are confined to the screen by the same mask.
+    if grade > 0:
+        warped_screen = _grade.match_light(photo, warped_screen, warped_mask, strength=grade)
+
+    mask3 = cv2.merge([warped_mask] * 3).astype(np.float32) / 255.0
+    out = photo.astype(np.float32) * (1 - mask3) + warped_screen.astype(np.float32) * mask3
+    out = np.clip(out, 0, 255).astype(np.uint8)
+
+    if grain:
+        sigma = _grade.measure_grain(photo, _grade.surround_ring(warped_mask))
+        out = _grade.add_grain(out, warped_mask, sigma)
+    if screen_off is not None:
+        out = _grade.specular_lift(out, screen_off, warped_mask, strength=specular)
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--photo", required=True, help="Path to the device photo")
+    ap.add_argument("--screenshot", required=True, help="Path to the UI screenshot to inject")
+    ap.add_argument("--corners", required=True, help="JSON [[x,y]x4] in the photo, order TL,TR,BR,BL")
+    ap.add_argument("--output", required=True, help="Output PNG path")
+    ap.add_argument("--corner-radius", type=float, default=0.0,
+                     help="Corner radius in SCREENSHOT source pixels (0 = square corners, M0 default)")
+    args = ap.parse_args()
+
+    photo = cv2.imread(args.photo, cv2.IMREAD_COLOR)
+    if photo is None:
+        sys.exit(f"error: could not read photo: {args.photo}")
+    screenshot = cv2.imread(args.screenshot, cv2.IMREAD_COLOR)
+    if screenshot is None:
+        sys.exit(f"error: could not read screenshot: {args.screenshot}")
+
+    try:
+        corners = json.loads(args.corners)
+    except json.JSONDecodeError as e:
+        sys.exit(f"error: --corners is not valid JSON: {e}")
+    if len(corners) != 4 or any(len(c) != 2 for c in corners):
+        sys.exit("error: --corners must be a JSON list of exactly 4 [x, y] pairs")
+
+    try:
+        composite = compose(photo, screenshot, corners, args.corner_radius)
+    except ValueError as e:
+        sys.exit(f"error: {e}")
+    sh, sw = screenshot.shape[:2]
+    ph, pw = photo.shape[:2]
+
+    ok = cv2.imwrite(args.output, composite, [cv2.IMWRITE_PNG_COMPRESSION, 9])
+    if not ok:
+        sys.exit(f"error: could not write output: {args.output}")
+
+    print(json.dumps({
+        "output": args.output,
+        "photo_size": [pw, ph],
+        "screenshot_size": [sw, sh],
+        "dst_quad": corners,
+        "corner_radius": args.corner_radius,
+    }))
+
+
+if __name__ == "__main__":
+    main()

package/skills/inject-screenshot/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: inject-screenshot
+description: Injects a UI screenshot onto a photographed device screen (phone/tablet/laptop) at any angle, matching the perspective exactly via homography — geometry, not AI generation. Use when the user wants to composite a screen design into a real device photo for a portfolio, case study, or mockup, and needs the result to look like a genuine photo rather than a template. Opens a local browser UI for picking files, correcting corners and saving.
+---
+
+# Inject a screenshot onto a photographed device
+
+**What ships (v0.13.1):** a local browser UI (`scripts/ui.py`) that walks the designer through the whole job — pick the photo and the screenshot (recent Desktop/Downloads images, drag-drop, browse, path, or a **Figma frame link**), auto-detect the screen as a starting position, then **match the four edges** (drag an edge's middle to slide it, near an end to pivot; corners still draggable) with canvas zoom/pan and a rectified strip loupe, Preview (in a popup, or continuously in the compare pane), an on-by-default realism pass that colour-matches the screenshot to the photo's light, Save into the project folder (`--out-dir`), and a **Send to Claude** button that reaches you through the plugin's own MCP server. The UI is a hand port of the project's Figma design file — dark only.
+
+The geometry is exact (`warp.py`); the detection is advisory (`detect.py`) and the human corrects it.
+
+**The realism pass ships and is ON by default** (`grade.py`, M2): it matches the injected screen's white balance and grain to the light around it, at a strength the designer sets in the rail. It can also lift the device's real specular highlights from a screen-off reference frame, though the UI cannot supply one yet. Off is a first-class choice and keeps the screenshot's colour exactly — say so if the user is reviewing brand colour.
+
+Still missing: **no ML detection** (M4 — measured, and it segments the phone body rather than the glass, so it is not shipped), **no occluder handling** — a finger or glare in front of the screen gets painted over (M5) — and **no video** (M3). Say so if it matters for the photo.
+
+**Runs on the user's Mac shell** (Desktop Commander `start_process` or equivalent). The sandboxed Linux shell can't open a browser or reach `~/Desktop`. Paths below are relative to the plugin root — two levels up from this file.
+
+## Workflow
+
+### 0. Preflight — every time, before promising anything
+
+```bash
+python3 scripts/preflight.py
+```
+
+Read the JSON. If `ready` is true, note `python` — **use that interpreter for every command below** (it's the venv at `~/.screengraft/venv`, not system Python). If `ready` is false:
+
+- Tell the user plainly what's missing and that **OpenCV is the engine: without it nothing runs — not worse results, no results.**
+- Ask with `AskUserQuestion` whether to run the install: `python3 scripts/preflight.py --install` (creates `~/.screengraft/venv`, pip-installs `opencv-python-headless` + `numpy`, ~60 MB, touches nothing else). Run it only after a yes. This is the **only** interview question this skill asks in chat — everything else happens in the UI.
+
+### 1. Launch the UI — with the project folder as the output directory
+
+```bash
+scripts/launch.sh --out-dir "<the user's current project folder>/mockups"
+```
+
+**Always pass `--out-dir`** when you know the folder the user is working in. Two reasons, and the second is not optional: saves land where the designer actually is rather than on the Desktop, and `present_files` **refuses any path outside a connected folder** — so with the default Desktop output, the "Import to Claude" button cannot work at all. If you genuinely have no project folder, omit the flag and tell the user that Import will be unavailable.
+
+**Do not launch `ui.py` directly with `nohup ... &` from your own shell.** That was tried on 3 Sep 2026 and the server died silently between turns, twice, losing whatever the user had already entered — the shell session that launches it can be torn down out from under a merely-backgrounded child. `launch.sh` starts it with `--daemon`, which double-forks and calls `setsid`, putting the server in its own session with no controlling terminal; it survives the launching shell and opens no window. It self-checks (waits for startup output, then confirms the server responds) before returning.
+
+A Terminal.app window was the previous fix for the same problem. It worked but left a dead "[Process completed]" window behind after every session, and closing those from AppleScript proved unreliable — Terminal reports stale ttys for dead windows and leaves zero-tab husks that `close` reports success on. The daemon removes the window entirely, so there is nothing to clean up.
+
+It prints one JSON line — `url`, `session`, `job`, `result`, `out_dir` — and opens the browser tab itself. If it exits non-zero, read the error and the log path it names before telling the user anything is ready.
+
+**Verify liveness again right before telling the user to interact with it** — `curl -sf <url>api/state` — especially if any time has passed since launch. If that fails, the server died; say so, relaunch, and have the user redo their last action rather than assuming it's still there.
+
+**Then explain the job in chat.** The page deliberately carries no onboarding — the explanation belongs here, where the user already is. Say this, in your own words but keeping all of it:
+
+> **What this does** — it computes the perspective between your photo and your screenshot, so the screenshot lands on the glass exactly. Geometry, not AI: nothing is invented and your pixels are unchanged.
+>
+> **1 · Choose a photo, then a screenshot.** Recent images from Desktop and Downloads are listed for you — or drag a file in, browse, paste a path, or paste a Figma frame link and I'll export it.
+>
+> **2 · Match the four edges to the screen.** Drag an edge's middle to slide it, or near an end to pivot — only that edge moves. The magnified strip below shows the boundary straightened, so aligned reads as flat. Arrow keys nudge 1px, Shift+arrow 10px, Tab moves to the next edge.
+>
+> **3 · Preview, then Save**, then **Send to Claude** and I'll check the result and show it here. Saves go to `<out-dir>`.
+>
+> A detector proposes a starting quad, but it's only a guess — you confirm all four edges. That's deliberate: a confident-looking wrong result is the one failure this tool won't risk.
+
+Adapt it: name the real output folder, and mention the realism pass only if it matters (it is on by default and changes the screenshot's colour, which is worth flagging if they are reviewing brand colour). Say it once, on launch — not again on every re-arm.
+
+Do not build a chat *interview* — the page collects every input, and duplicating its questions is what the one-interview-surface rule forbids. Explaining the workflow is not an interview. The page scans `~/Desktop` and `~/Downloads` for recent images itself, every launch.
+
+### 2. Park in `wait_for_job` — this is the main loop, not an optional extra
+
+**You cannot poll.** You run in turns; between them nothing of you is executing. An earlier version of this file told you to "poll `job.json` every few seconds" and the page told the user "(it watches this job)" — both false, and the user sat waiting for an agent that was not running. Do not reproduce that in chat: never tell the user you are watching, monitoring, or keeping an eye on anything.
+
+What you *can* do is block. Immediately after launching the UI, call:
+
+```
+wait_for_job(timeout_s=90)
+```
+
+It parks until the user presses a button and returns within ~150 ms of the press. Handle what comes back, then **call it again**. That loop is how the page reaches you.
+
+| result | what to do |
+|---|---|
+| `status=job`, `job.type="figma_export"` | Extract `fileKey` and `nodeId` from `job.url` (`1-2` → `1:2`), export via the Figma MCP (`download_assets`, PNG, scale 3), save to `job.save_to`, then `complete_job(status="done", path=<saved file>)`. Re-arm. |
+| `status=job`, `job.type="present"` | `present_files` on `job.paths`, report what you checked in the composite (§3), then `complete_job(status="done")`. Re-arm. |
+| `status=timeout` | Nothing pressed yet. Call again to keep waiting. Re-arm two or three times, then stop and say you've stopped waiting — do not loop forever burning turns. |
+| `status=ui_closed` | The UI exited. Stop; say so. |
+| `status=no_ui` | Nothing is running — launch it first. |
+
+Pass the job's `id` back as `job_id` when you complete it. If the user gave up and started something else while you were working, that stops your late answer from marking their new request done and stranding them on a spinner.
+
+**Always `complete_job`, including on failure.** The page is polling for it and will sit on a spinner until it arrives. If the Figma MCP isn't available, `complete_job(status="error", message="…")` with a sentence the designer can act on — the page shows it and offers the manual route.
+
+While you are blocked you cannot do anything else, which is correct during a fit but means the user's own chat messages wait for the call to return. That is why the default is 90 s rather than the 150 s maximum: it bounds how long a message can sit behind the wait.
+
+**Don't raise `timeout_s` past the default hoping to park longer.** The host kills an MCP tool call at around 180 s — measured on 4 Sep 2026, when a `wait_for_job(300)` was killed at exactly 180 s. Nothing is lost when that happens (an unanswered job stays pending and the next wait picks it up), but you miss the wake you were parked for, which is the whole point. The server clamps to 150 s; re-arming is the way to wait longer, not a bigger number.
+
+### 3. When `<session>/result.json` appears: verify, then hand over
+
+The user pressed Save. Read the output image back (you can see images). Check:
+
+- The injected screen sits on the bezel edge all the way round — no sliver of the original screen showing, no UI poking past the glass. Zoom a corner if unsure.
+- Text in the injected area is sharp. Soft means double resampling — that's a bug, not a setting.
+- Nothing that was in front of the screen in the photo has been painted over (if it has, say so — M5).
+
+Then `present_files` the output. Report what you checked, not "done".
+
+If the user is unhappy, the UI is still open — they nudge and Save again; a new file is written (`-2`, `-3`, …), never overwritten.
+
+### 4. Finish
+
+The server is a detached daemon with no window. **Stop it with `scripts/stop.sh`, never a bare `pkill -9`.** stop.sh sends SIGTERM, which ui.py catches so its atexit clears the session pointer the MCP server reads; a hard kill leaves that pointer stale and the next `wait_for_job` then blocks a full timeout against a session nobody is in. Sessions live in `~/.screengraft/sessions/<timestamp>/` — leave them, they're small.
+
+## Rules
+
+- **Preflight first, install only on a yes.** OpenCV is required, full stop — never describe its absence as "reduced quality".
+- **One interview surface, but explain the job in chat.** The browser page collects every *input*; `AskUserQuestion` is for install consent only, and you must not re-ask in chat what the page already asks. Explaining what the tool does and what the three steps are is not an interview — it is the onboarding, it belongs in chat, and §1 gives the words.
+- **Never claim a composite is right without reading the output back.** Correct-looking code is not evidence; neither is the user clicking Save.
+- **Detection is advisory and is only a starting position; the warp is exact — keep the two claims apart.** No-ML detection was measured to its ceiling (see the design notes): it cannot tell a screen from a bezel from a body, because that is a semantic question. The edge-matching UI exists so a human fixes it in seconds, and the page shows green ONLY when both detectors corroborate each other.
+- **Testing the plugin ≠ doing the task.** If the user is testing screengraft and it can't do something, say what it can't do and propose the change. Don't reach past the plugin with ad-hoc scripts to make the result better.
+- **Never claim to be watching, monitoring, or waiting on something you aren't.** You have exactly one way to be reached from the page — being blocked inside `wait_for_job`. If you are not in that call, you are not reachable, and saying otherwise leaves the user waiting on nothing. This is the specific failure v0.7 was built to fix; don't reintroduce it in prose.
+
+## Scripts
+
+| File | What it does |
+|---|---|
+| `mcp/server.py` | The plugin's MCP server: `wait_for_job` / `complete_job`. Stdlib only on system `python3`, deliberately — it must load before preflight has built the venv, or the tools would silently be missing on a fresh install. |
+| `scripts/preflight.py` | Dependency report; `--install` builds the venv |
+| `scripts/launch.sh` | Starts `ui.py` as a detached daemon (no window) and verifies it's alive — use this, not `ui.py` directly |
+| `scripts/stop.sh` | Stops the UI with SIGTERM so the session pointer is cleared — use this instead of `pkill` |
+| `scripts/ui.py` | Local server + browser UI; calls the two below |
+| `scripts/detect.py` | Advisory screen-quad + corner-radius detection (no ML) |
+| `scripts/warp.py` | The engine: `compose()` and a CLI for scripted use |
+| `scripts/scan.py` | Recent images on Desktop/Downloads, thumbnails |
+| `ui/index.html` | The page |
+
+Design rationale and the roadmap live with the project's own notes, not in the plugin.

package/ui/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Mona Sans Project Authors (https://github.com/github/mona-sans), with Reserved Font Name "Mona"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.