content-cli 0.2.0__py3-none-any.whl

content_cli/__init__.py

@@ -0,0 +1,3 @@
+"""content — command-line client for the Content engine."""
+
+__version__ = "0.1.0"

content_cli/__main__.py

@@ -0,0 +1,4 @@
+from content_cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

content_cli/builders.py

@@ -0,0 +1,119 @@
+"""Ergonomic shortcuts normalized to the canonical public contract.
+
+These are pure functions (no I/O) so they are trivially testable and can be
+validated against the back-end's Pydantic schema. The CLI never invents a
+parallel contract — every shortcut produces a standard GenerationRequest.
+"""
+
+SB_PRESETS: dict[str, dict | None] = {
+    "disabled": None,
+    "default": {
+        "remove": ["sponsor", "interaction", "selfpromo"],
+        "mark": ["intro", "preview", "outro"],
+    },
+    "aggressive": {
+        "remove": ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview"],
+        "mark": [],
+    },
+    "minimal": {"remove": ["sponsor"], "mark": []},
+}
+
+
+def _split(value: str | None) -> list[str]:
+    return [x.strip() for x in (value or "").split(",") if x.strip()]
+
+
+def url_source(url: str, credential: str | None = None) -> dict:
+    src: dict = {"id": "main", "type": "url", "uri": url.strip()}
+    if credential:
+        src["auth"] = {"credential_id": credential}
+    return src
+
+
+def _delivery(folder: str | None, name: str | None) -> dict:
+    delivery: dict = {}
+    if folder:
+        delivery["folder"] = folder
+    if name:
+        delivery["filename"] = name
+    return delivery
+
+
+def video_request(
+    url: str,
+    *,
+    height: int | None = 1080,
+    codec: str = "auto",
+    container: str = "source",
+    subtitles: str | None = None,
+    audio_languages: str | None = None,
+    sponsorblock: str = "disabled",
+    playlist: bool = False,
+    credential: str | None = None,
+    folder: str | None = None,
+    name: str | None = None,
+    reuse: bool = True,
+) -> dict:
+    selection: dict = {}
+    if height:
+        selection["max_height"] = height
+    if codec != "auto":
+        selection["video_codec"] = {"mode": "prefer", "value": codec}
+    if audio_languages:
+        selection["audio_languages"] = _split(audio_languages)
+    options: dict = {"selection": selection, "container": container}
+    subs = _split(subtitles)
+    if subs:
+        options["processing"] = {"embed_subtitles": subs}
+    sb = SB_PRESETS.get(sponsorblock)
+    if sb:
+        options["sponsorblock"] = sb
+    output: dict = {"id": "video_main", "type": "video", "options": options}
+    if playlist:
+        output["scope"] = "each_item"
+    delivery = _delivery(folder, name)
+    if delivery:
+        output["delivery"] = delivery
+    return {
+        "schema_version": "1.0",
+        "sources": [url_source(url, credential)],
+        "outputs": [output],
+        "execution": {"reuse_existing": reuse},
+    }
+
+
+def audio_request(
+    url: str,
+    *,
+    fmt: str = "source",
+    languages: str | None = None,
+    sponsorblock: str = "disabled",
+    playlist: bool = False,
+    credential: str | None = None,
+    folder: str | None = None,
+    name: str | None = None,
+    reuse: bool = True,
+) -> dict:
+    options: dict = {}
+    if fmt != "source":
+        options["format"] = fmt
+    langs = _split(languages)
+    if langs:
+        options["languages"] = langs
+    sb = SB_PRESETS.get(sponsorblock)
+    if sb:
+        options["sponsorblock"] = sb
+    output: dict = {"id": "audio_main", "type": "audio"}
+    if options:
+        output["options"] = options
+    if playlist:
+        output["scope"] = "each_item"
+    delivery = _delivery(folder, name)
+    if delivery:
+        output["delivery"] = delivery
+    return {
+        "schema_version": "1.0",
+        "sources": [url_source(url, credential)],
+        "outputs": [output],
+        "execution": {"reuse_existing": reuse},
+    }

content_cli/cli.py

@@ -0,0 +1,310 @@
+"""``content`` — the command-line client for the Content engine.
+
+A thin wrapper over the official SDK (``content_sdk``): it parses arguments,
+calls the SDK, and prints results. It never speaks HTTP itself, never runs the
+planner, yt-dlp or ffmpeg — the SDK is the only door to the engine.
+"""
+
+import argparse
+import json
+import sys
+import time
+
+from content_sdk import ContentClient, ContentError, TransportError
+from content_sdk.resources import TERMINAL_STATUSES
+
+from content_cli import __version__
+from content_cli.builders import audio_request, video_request
+
+
+def _out(obj, as_json: bool) -> None:
+    print(json.dumps(obj, indent=2, ensure_ascii=False) if as_json else obj)
+
+
+def _print_job(job: dict) -> None:
+    print(f"{job['status']}  {job['job_id']}")
+    for step in job.get("steps", []):
+        err = f"  ! {step['error']}" if step.get("error") else ""
+        print(f"  [{step['status']:>9}] {step['step_id']}{err}")
+
+
+def _watch(client: ContentClient, job_id: str) -> str:
+    """Stream events until the job reaches a terminal state."""
+    seen = 0
+    while True:
+        for event in client.events(job_id, after_sequence=seen):
+            seen = event.sequence
+            print(f"  {event.sequence:>3} {event.type} {event.data or ''}")
+        status = client.get_job(job_id).status
+        if status in TERMINAL_STATUSES:
+            print(f"→ {status}")
+            return status
+        time.sleep(2.0)
+
+
+def _submit_and_maybe_watch(client: ContentClient, request: dict, args) -> int:
+    job = client.submit(request)
+    for warning in job.data.warnings:
+        print(f"warning: {warning['code']}: {warning['message']}", file=sys.stderr)
+    print(job.id)
+    if getattr(args, "watch", False):
+        status = _watch(client, job.id)
+        return 0 if status in ("succeeded", "partially_succeeded") else 1
+    return 0
+
+
+def _cmd_analyze(client: ContentClient, args) -> int:
+    source: dict = {"id": "main", "type": args.type}
+    if args.type == "url":
+        source["uri"] = args.target
+    elif args.type == "file":
+        source["path"] = args.target
+    else:
+        source["content"] = args.target
+    if args.credential:
+        source["auth"] = {"credential_id": args.credential}
+    analysis = client.analyze([source])
+    entry = analysis.sources[0]
+    if args.json:
+        _out(entry.model_dump(), True)
+        return 0
+    print(f"{entry.resource_type} · {entry.title or '(untitled)'}")
+    # An analysis is addressable (ADR 0014): resolve what can be produced from it.
+    caps = client.get_capabilities(analysis.id)
+    for cap in caps.sources[0].capabilities:
+        print(f"  {cap.status:>11}  {cap.id}")
+    if entry.entries:
+        print(f"  collection: {len(entry.entries)} items")
+    print(f"analysis_id: {analysis.id}")
+    return 0
+
+
+def _cmd_submit(client: ContentClient, args) -> int:
+    if args.file == "-":
+        raw = sys.stdin.read()
+    else:
+        with open(args.file) as handle:
+            raw = handle.read()
+    return _submit_and_maybe_watch(client, json.loads(raw), args)
+
+
+def _cmd_video(client: ContentClient, args) -> int:
+    request = video_request(
+        args.url,
+        height=args.height,
+        codec=args.codec,
+        container=args.container,
+        subtitles=args.subs,
+        audio_languages=args.audio_langs,
+        sponsorblock=args.sponsorblock,
+        playlist=args.playlist,
+        credential=args.credential,
+        folder=args.folder,
+        name=args.name,
+    )
+    return _submit_and_maybe_watch(client, request, args)
+
+
+def _cmd_audio(client: ContentClient, args) -> int:
+    request = audio_request(
+        args.url,
+        fmt=args.format,
+        languages=args.audio_langs,
+        sponsorblock=args.sponsorblock,
+        playlist=args.playlist,
+        credential=args.credential,
+        folder=args.folder,
+        name=args.name,
+    )
+    return _submit_and_maybe_watch(client, request, args)
+
+
+def _cmd_download(client: ContentClient, args) -> int:
+    data = client.artifact_bytes(args.artifact_id)
+    if args.output == "-":
+        sys.stdout.buffer.write(data)
+    else:
+        with open(args.output, "wb") as handle:
+            handle.write(data)
+        print(f"wrote {len(data)} bytes to {args.output}")
+    return 0
+
+
+def _add_launch_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--credential", help="server-side cookie credential id")
+    parser.add_argument("--folder", help="delivery sub-folder")
+    parser.add_argument("--name", help="delivery file base name")
+    parser.add_argument("--sponsorblock", default="disabled", help="SB preset")
+    parser.add_argument("--audio-langs", dest="audio_langs", help="comma-separated")
+    parser.add_argument(
+        "--playlist", action="store_true", help="download each playlist item"
+    )
+    parser.add_argument("--watch", action="store_true", help="follow until done")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="content", description=__doc__)
+    parser.add_argument("--api-url", dest="api_url", help="Content API base URL")
+    parser.add_argument("--json", action="store_true", help="raw JSON output")
+    # The installed release, from the package's own metadata rather than a
+    # second literal: `content --version` must answer for the wheel a user
+    # actually has, which is the first thing to check in a bug report.
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"content {__version__}",
+        help="show the installed Content CLI version",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("health")
+    sub.add_parser("config")
+
+    p = sub.add_parser("analyze", help="analyze a source")
+    p.add_argument("target")
+    p.add_argument("--type", default="url", choices=["url", "file", "text"])
+    p.add_argument("--credential")
+
+    p = sub.add_parser("analysis", help="fetch a stored analysis by id")
+    p.add_argument("analysis_id")
+
+    p = sub.add_parser("video", help="download a video (shortcut)")
+    p.add_argument("url")
+    p.add_argument("--height", type=int, default=1080)
+    p.add_argument("--codec", default="auto", choices=["auto", "av1", "vp9", "h264"])
+    p.add_argument("--container", default="source", choices=["source", "mkv", "mp4"])
+    p.add_argument("--subs", help="subtitle languages to embed (comma-separated)")
+    _add_launch_flags(p)
+
+    p = sub.add_parser("audio", help="download audio (shortcut)")
+    p.add_argument("url")
+    p.add_argument(
+        "--format", default="source", choices=["source", "opus", "mp3", "m4a"]
+    )
+    _add_launch_flags(p)
+
+    p = sub.add_parser("submit", help="submit a GenerationRequest JSON (file or -)")
+    p.add_argument("file")
+    p.add_argument("--watch", action="store_true")
+
+    p = sub.add_parser("jobs", help="list recent jobs")
+    p.add_argument("--limit", type=int, default=20)
+
+    p = sub.add_parser("job", help="show a job")
+    p.add_argument("job_id")
+
+    p = sub.add_parser("watch", help="follow a job until it ends")
+    p.add_argument("job_id")
+
+    p = sub.add_parser("artifacts", help="list a job's artifacts")
+    p.add_argument("job_id")
+
+    p = sub.add_parser("download", help="download an artifact")
+    p.add_argument("artifact_id")
+    p.add_argument("-o", "--output", default="-", help="output file, or - for stdout")
+
+    p = sub.add_parser("cancel")
+    p.add_argument("job_id")
+    p = sub.add_parser("retry")
+    p.add_argument("job_id")
+    return parser
+
+
+def run(argv: list[str], client: ContentClient) -> int:
+    args = build_parser().parse_args(argv)
+    cmd = args.command
+    if cmd == "health":
+        _out(client.health(), True)
+    elif cmd == "config":
+        _out(client.config(), True)
+    elif cmd == "analyze":
+        return _cmd_analyze(client, args)
+    elif cmd == "analysis":
+        _out(client.get_analysis(args.analysis_id).data.model_dump(), True)
+    elif cmd == "video":
+        return _cmd_video(client, args)
+    elif cmd == "audio":
+        return _cmd_audio(client, args)
+    elif cmd == "submit":
+        return _cmd_submit(client, args)
+    elif cmd == "jobs":
+        rows = client.list_jobs(limit=args.limit)
+        if args.json:
+            _out([r.model_dump() for r in rows], True)
+        else:
+            for row in rows:
+                print(f"{row.status:>11}  {row.job_id}")
+    elif cmd == "job":
+        job = client.get_job(args.job_id).data.model_dump()
+        _out(job, True) if args.json else _print_job(job)
+    elif cmd == "watch":
+        status = _watch(client, args.job_id)
+        return 0 if status in ("succeeded", "partially_succeeded") else 1
+    elif cmd == "artifacts":
+        arts = client.artifacts(args.job_id)
+        if args.json:
+            _out([a.model_dump() for a in arts], True)
+        else:
+            for a in arts:
+                print(f"{a.id}  {a.filename}  {a.size_bytes}B")
+    elif cmd == "download":
+        return _cmd_download(client, args)
+    elif cmd == "cancel":
+        _out(client.cancel(args.job_id), True)
+    elif cmd == "retry":
+        _out(client.retry(args.job_id).data.model_dump(), True)
+    return 0
+
+
+def _describe(exc: ContentError) -> str:
+    """One readable line per problem, from the contract's own error shape.
+
+    Every rejection now comes back as `{detail: {errors: [{code, path,
+    message}]}}` — one shape for schema violations and engine refusals alike —
+    so there is no reason to print a raw Python dict at somebody.
+    """
+    if isinstance(exc, TransportError):
+        return f"cannot reach the engine — {exc}"
+    body = getattr(exc, "body", None)
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, dict) and isinstance(detail.get("errors"), list):
+        lines = []
+        for error in detail["errors"]:
+            where = f" at {error['path']}" if error.get("path") else ""
+            code = f" [{error['code']}]" if error.get("code") else ""
+            lines.append(f"{error.get('message', 'rejected')}{where}{code}")
+        return "\n       ".join(lines)
+    if isinstance(detail, str):
+        return detail
+    return str(body if body is not None else exc)
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    # Peel the global --api-url before argparse sees it, so it can be given
+    # before the subcommand. A missing value used to raise IndexError here —
+    # a traceback for a typo.
+    api_url = None
+    if "--api-url" in argv:
+        i = argv.index("--api-url")
+        if i + 1 >= len(argv):
+            print("error: --api-url needs a value", file=sys.stderr)
+            return 2
+        api_url = argv[i + 1]
+        del argv[i : i + 2]
+    client = ContentClient(api_url)
+    try:
+        return run(argv, client)
+    # ContentError, not APIError: a refused connection raises TransportError,
+    # and "the engine is not running" is the most common failure of all — it
+    # used to print a sixty-line traceback.
+    except ContentError as exc:
+        print(f"error: {_describe(exc)}", file=sys.stderr)
+        return 2
+    except (OSError, ValueError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

content_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: content-cli
+Version: 0.2.0
+Summary: Command-line client for the Content engine (talks to /api/v1).
+Project-URL: Homepage, https://github.com/LatentNoise/content
+Project-URL: Source, https://github.com/LatentNoise/content
+Project-URL: Issues, https://github.com/LatentNoise/content/issues
+Project-URL: Documentation, https://github.com/LatentNoise/content/blob/main/docs/README.md
+Author: Yann Orieult
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+License-File: NOTICE
+Keywords: cli,content,media,self-hosted,yt-dlp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: content-sdk==0.2.0
+Description-Content-Type: text/markdown
+
+# `content` — Content CLI
+
+A thin command-line client for the Content engine, built on the official
+[Python SDK](../../packages/python-sdk/README.md) (`content_sdk`) — it never
+speaks HTTP itself and never runs the planner, yt-dlp or ffmpeg. Ergonomic
+shortcuts (`video`, `audio`) are normalized to canonical `GenerationRequest`s;
+there is no parallel contract.
+
+## Install
+
+Once published, the CLI is an ordinary Python application — nothing to clone:
+
+```bash
+uv tool install content-cli     # isolated, on your PATH — recommended
+content --help
+
+# or
+pipx install content-cli
+```
+
+`content-cli` pulls `content-sdk` from PyPI as an ordinary dependency, pinned
+to the matching release.
+
+> **Not published yet.** Until the first publication the packages are attached
+> to each GitHub release as wheels; see *From a release* below. The commands
+> above are what will work afterwards.
+
+### From a release (today)
+
+Download `content_sdk-<version>-py3-none-any.whl` and
+`content_cli-<version>-py3-none-any.whl` from the
+[latest release](https://github.com/LatentNoise/content/releases/latest), then:
+
+```bash
+uv tool install ./content_cli-<version>-py3-none-any.whl \
+    --find-links .          # --find-links lets it resolve the SDK beside it
+```
+
+### From a clone
+
+```bash
+pip install ./packages/python-sdk ./apps/cli     # exposes `content`
+```
+
+### For development
+
+```bash
+make install    # editable installs of the engine, SDK, CLI and MCP in one venv
+```
+
+Build the distributions yourself with `make wheels` (they land in `dist/`).
+
+### Point it at your engine
+
+`--api-url URL` or `CONTENT_API_URL` (default `http://localhost:8010`):
+
+```bash
+export CONTENT_API_URL=http://nas.local:8010
+content health
+```
+
+## Commands
+
+```bash
+content health
+content config
+content analyze https://youtu.be/… [--credential youtube]
+content analysis <analysis_id>           # re-fetch a stored analysis (ADR 0014)
+content video  https://youtu.be/… --height 1080 --container mkv --subs en,fr --watch
+content audio  https://youtu.be/… --format opus --folder music --name track --watch
+content video  https://…/playlist?list=… --playlist --watch      # each item
+content submit request.json --watch      # raw GenerationRequest (or - for stdin)
+content jobs
+content job    <job_id>
+content watch  <job_id>
+content artifacts <job_id>
+content download <artifact_id> -o out.mkv
+content cancel <job_id> ; content retry <job_id>
+```
+
+Global flags: `--api-url URL` and `--json` (raw JSON output) go before the
+subcommand. Exit code is non-zero on API errors or a failed watched job.

content_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+content_cli/__init__.py,sha256=VFYxWH1qJJJ4z8A3i4HRyqPREYJJZUuBCbo43K8vLfg,85
+content_cli/__main__.py,sha256=9lyRRqrpVrCBYTiaz5xRwl-7xzsF-TbxKrocK0zX2XM,90
+content_cli/builders.py,sha256=uLRBDlnAupSpIgfV0UBlPc6IRsuNCogBGiAzKMIoa54,3519
+content_cli/cli.py,sha256=pbTG6NSIMCIJx8nAZ9oFZvLL_XmwDyFXe-Ce9E5sUU8,11336
+content_cli-0.2.0.dist-info/METADATA,sha256=yhFkqxpXdsv9l8M5bJrzxw_p1CFhehhv3aoIgNxjpH4,3693
+content_cli-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+content_cli-0.2.0.dist-info/entry_points.txt,sha256=-vC1YdvQAGa_AUqpq88zguX008NN2GBm_M-dTyQd1Ck,49
+content_cli-0.2.0.dist-info/licenses/LICENSE,sha256=UzbgYnVAKZ_x28AC54pY4P1QmwYSVhDF8QJu-WpfK6I,34522
+content_cli-0.2.0.dist-info/licenses/NOTICE,sha256=0uIDSiuf2W9Uk6j45FqjuhiXV0uN6MaHmyX68La_kic,2816
+content_cli-0.2.0.dist-info/RECORD,,

content_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

content_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+content = content_cli.cli:main

content_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,683 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft
+license for software and other kinds of works, specifically designed to
+ensure cooperation with the community in the case of network server
+software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This
+is a different license, not a version of the Affero GPL, but Affero
+has released a new version of the Affero GPL which permits relicensing
+under this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General
+Public License.
+
+  "Copyright" also means copyright-like laws that apply to other
+kinds of works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the
+work in a fashion requiring copyright permission, other than the
+making of an exact copy.  The resulting work is called a "modified
+version" of the earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work
+based on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables
+other parties to make or receive copies.  Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an
+official standard defined by a recognized standards body, or, in the
+case of interfaces specified for a particular programming language,
+one that is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything,
+other than the work as a whole, that (a) is included in the normal
+form of packaging a Major Component, but which is not part of that
+Major Component, and (b) serves only to enable use of the work with
+that Major Component, or to implement a Standard Interface for which
+an implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means
+all the source code needed to generate, install, and (for an
+executable work) run the object code and to modify the work,
+including scripts to control those activities.  However, it does not
+include the work's System Libraries, or general-purpose tools or
+generally available free programs which are used unmodified in
+performing those activities but which are not part of the work.  For
+example, Corresponding Source includes interface definition files
+associated with source files for the work, and the source code for
+shared libraries and dynamically linked subprograms that the work is
+specifically designed to require, such as by intimate data
+communication or control flow between those subprograms and other
+parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole
+purpose of having them make modifications exclusively for you, or
+provide you with facilities for running those works, provided that
+you comply with the terms of this License in conveying all material
+for which you do not control copyright.  Those thus making or running
+the covered works for you must do so exclusively on your behalf,
+under your direction and control, on terms that prohibit them from
+making any copies of your copyrighted material outside their
+relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to
+forbid circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License
+with respect to the covered work, and you disclaim any intention to
+limit operation or modification of the work as a means of enforcing,
+against the work's users, your or third parties' legal rights to
+forbid circumvention of technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as
+you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the
+code; keep intact all notices of the absence of any warranty; and
+give all recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you
+convey, and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications
+to produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and
+independent works, which are not by their nature extensions of the
+covered work, and which are not combined with it such as to form a
+larger program, in or on a volume of a storage or distribution
+medium, is called an "aggregate" if the compilation and its
+resulting copyright are not used to limit the access or legal rights
+of the compilation's users beyond what the individual works permit.
+Inclusion of a covered work in an aggregate does not cause this
+License to apply to the other parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this
+License, in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is
+excluded from the Corresponding Source as a System Library, need not
+be included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means
+any tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling.  In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage.  For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the
+way in which the particular user actually uses, or expects or is
+expected to use, the product.  A product is a consumer product
+regardless of whether the product has substantial commercial,
+industrial or non-consumer uses, unless such uses represent the only
+significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source.  The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+  If you convey an object code work under this section in, or with,
+or specifically for use in, a User Product, and the conveying occurs
+as part of a transaction in which the right of possession and use of
+the User Product is transferred to the recipient in perpetuity or for
+a fixed term (regardless of how the transaction is characterized),
+the Corresponding Source conveyed under this section must be
+accompanied by the Installation Information.  But this requirement
+does not apply if neither you nor any third party retains the
+ability to install modified object code on the User Product (for
+example, the work has been installed in ROM).
+
+  The requirement to provide Installation Information does not
+include a requirement to continue to provide support service,
+warranty, or updates for a work that has been modified or installed
+by the recipient, or for the User Product in which it has been
+modified or installed.  Access to a network may be denied when the
+modification itself materially and adversely affects the operation of
+the network or violates the rules and protocols for communication
+across the network.
+
+  Corresponding Source conveyed, and Installation Information
+provided, in accord with this section must be in a format that is
+publicly documented (and with an implementation available to the
+public in source code form), and must require no special password or
+key for unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of
+this License by making exceptions from one or more of its
+conditions.  Additional permissions that are applicable to the
+entire Program shall be treated as though they were included in this
+License, to the extent that they are valid under applicable law.  If
+additional permissions apply only to part of the Program, that part
+may be used separately under those permissions, but the entire
+Program remains governed by this License without regard to the
+additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part
+of it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material
+you add to a covered work, you may (if authorized by the copyright
+holders of that material) supplement the terms of this License with
+terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as
+you received it, or any part of it, contains a notice stating that it
+is governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document
+contains a further restriction but permits relicensing or conveying
+under this License, you may add to a covered work material governed
+by the terms of that license document, provided that the further
+restriction does not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section,
+you must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in
+the form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as
+expressly provided under this License.  Any attempt otherwise to
+propagate or modify it is void, and will automatically terminate your
+rights under this License (including any patent licenses granted
+under the third paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the
+copyright holder fails to notify you of the violation by some
+reasonable means prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from
+that copyright holder, and you cure the violation prior to 30 days
+after your receipt of the notice.
+
+  Termination of your rights under this section does not terminate
+the licenses of parties who have received copies or rights from you
+under this License.  If your rights have been terminated and not
+permanently reinstated, you do not qualify to receive new licenses
+for the same material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer
+transmission to receive a copy likewise does not require acceptance.
+However, nothing other than this License grants you permission to
+propagate or modify any covered work.  These actions infringe
+copyright if you do not accept this License.  Therefore, by
+modifying or propagating a covered work, you indicate your
+acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not
+responsible for enforcing compliance by third parties with this
+License.
+
+  An "entity transaction" is a transaction transferring control of
+an organization, or substantially all assets of one, or subdividing
+an organization, or merging organizations.  If propagation of a
+covered work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate
+litigation (including a cross-claim or counterclaim in a lawsuit)
+alleging that any patent claim is infringed by making, using,
+selling, offering for sale, or importing the Program or any portion
+of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under
+this License of the Program or a work on which the Program is based.
+The work thus licensed is called the contributor's "contributor
+version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor
+version, but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide,
+royalty-free patent license under the contributor's essential patent
+claims, to make, use, sell, offer for sale, import and otherwise
+run, modify and propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any
+express agreement or commitment, however denominated, not to enforce
+a patent (such as an express permission to practice a patent or
+covenant not to sue for patent infringement).  To "grant" such a
+patent license to a party means to make such an agreement or
+commitment not to enforce a patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent
+license, and the Corresponding Source of the work is not available
+for anyone to copy, free of charge and under the terms of this
+License, through a publicly available network server or other
+readily accessible means, then you must either (1) cause the
+Corresponding Source to be so available, or (2) arrange to deprive
+yourself of the benefit of the patent license for this particular
+work, or (3) arrange, in a manner consistent with the requirements
+of this License, to extend the patent license to downstream
+recipients.  "Knowingly relying" means you have actual knowledge
+that, but for the patent license, your conveying the covered work in
+a country, or your recipient's use of the covered work in a country,
+would infringe one or more identifiable patents in that country that
+you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate,
+modify or convey a specific copy of the covered work, then the
+patent license you grant is automatically extended to all recipients
+of the covered work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that
+are specifically granted under this License.  You may not convey a
+covered work if you are a party to an arrangement with a third party
+that is in the business of distributing software, under which you
+make payment to the third party based on the extent of your activity
+of conveying the work, and under which the third party grants, to
+any of the parties who would receive the covered work from you, a
+discriminatory patent license (a) in connection with copies of the
+covered work conveyed by you (or copies made from those copies), or
+(b) primarily for and in connection with specific products or
+compilations that contain the covered work, unless you entered into
+that arrangement, or that patent license was granted, prior to 28
+March 2007.
+
+  Nothing in this License shall be construed as excluding or
+limiting any implied license or other defenses to infringement that
+may otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order,
+agreement or otherwise) that contradict the conditions of this
+License, they do not excuse you from the conditions of this License.
+If you cannot convey a covered work so as to satisfy simultaneously
+your obligations under this License and any other pertinent
+obligations, then as a consequence you may not convey it at all.
+For example, if you agree to terms that obligate you to collect a
+royalty for further conveying from those to whom you convey the
+Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify
+the Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your
+version supports such interaction) an opportunity to receive the
+Corresponding Source of your version by providing access to the
+Corresponding Source from a network server at no charge, through
+some standard or customary means of facilitating copying of software.
+This Corresponding Source shall include the Corresponding Source for
+any work covered by version 3 of the GNU General Public License that
+is incorporated pursuant to the following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered
+work, but the work with which it is combined will remain governed by
+version 3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new
+versions of the GNU Affero General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero
+General Public License "or any later version" applies to it, you have
+the option of following the terms and conditions either of that
+numbered version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version
+number of the GNU Affero General Public License, you may choose any
+version ever published by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that
+proxy's public statement of acceptance of a version permanently
+authorizes you to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE
+COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
+WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY
+AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES
+AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
+DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM
+(INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
+INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
+THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
+OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the
+greatest possible use to the public, the best way to achieve this is
+to make it free software which everyone can redistribute and change
+under these terms.
+
+  To do so, attach the following notices to the program.  It is
+safest to attach them to the start of each source file to most
+effectively state the exclusion of warranty; and each file should
+have at least the "copyright" line and a pointer to where the full
+notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public
+    License along with this program.  If not, see
+    <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+  If your software can interact with users remotely through a
+computer network, you should also make sure that it provides a way
+for users to get its source.  For example, if your program is a web
+application, its interface could display a "Source" link that leads
+users to an archive of the code.  There are many ways you could
+offer source, and different solutions will be better for different
+programs; see section 13 for the specific requirements.
+
+  You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  For more information on this, and how to apply and
+follow the GNU AGPL, see <https://www.gnu.org/licenses/>.

content_cli-0.2.0.dist-info/licenses/NOTICE

@@ -0,0 +1,65 @@
+Content — declarative resource-to-artifact generation engine
+Copyright (C) 2026 Yann Orieult
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+Source: https://github.com/LatentNoise/content
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the Free
+Software Foundation, either version 3 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along
+with this program. If not, see <https://www.gnu.org/licenses/>.
+
+---
+
+Third-party components
+----------------------
+
+Content depends on third-party software that it does not include: yt-dlp,
+ffmpeg/ffprobe, Ollama, faster-whisper, and its Python dependencies. Each
+remains under its own licence, held by its own authors, and nothing here alters
+those terms. The container images built from this repository bundle some of
+these; consult each component for its licence.
+
+No additional restriction is imposed beyond the licences that apply.
+
+Redistributed in the container images
+-------------------------------------
+
+The official container images built from this repository include the following
+components in binary form. They are named here because redistribution, unlike a
+runtime dependency, carries attribution obligations.
+
+  Typst — https://github.com/typst/typst
+  Copyright (c) The Typst Project Developers
+  Licensed under the Apache License, Version 2.0.
+  A copy of that licence is installed in the image at
+  /usr/local/share/licenses/typst/LICENSE, and is available at
+  <http://www.apache.org/licenses/LICENSE-2.0>.
+  Used as the default PDF renderer; the binary is unmodified.
+  Omit it at build time with --build-arg INSTALL_TYPST=false.
+
+  ReportLab — https://www.reportlab.com/
+  Copyright (c) ReportLab Europe Ltd.
+  Licensed under the BSD 3-Clause License.
+  Installed as a Python wheel; used as the fallback PDF renderer.
+
+  DejaVu fonts — https://dejavu-fonts.github.io/
+  Licensed under the DejaVu Fonts License (a permissive, Bitstream Vera
+  derived licence). Installed via the Alpine `ttf-dejavu` package and used for
+  PDF output outside the Latin-1 repertoire.
+
+Copyright ownership
+-------------------
+
+Copyright in this project is held by its author alone. The project accepts no
+code contributions (see CONTRIBUTING.md), so no third party holds copyright in
+any part of it. That is deliberate: undivided ownership is what allows Content
+to be offered under separate commercial terms alongside the AGPL — see
+COMMERCIAL.md.