content-mcp 0.2.0__py3-none-any.whl

content_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Content MCP server package. The server wiring lives in ``server.py`` (it
+imports the ``mcp`` package); the tool logic lives in ``service.py`` (SDK only).
+"""

content_mcp/server.py

@@ -0,0 +1,148 @@
+"""The official Content MCP server — a thin agentic facade over the SDK.
+
+It exposes **intention-level** Tools (not one-per-endpoint) and read-only
+Resources, each delegating to ``service.py`` which speaks only the SDK. No REST,
+no business logic here. stdio transport (HTTP can come later).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from content_sdk import ContentClient
+from mcp.server import MCPServer
+
+from . import service
+
+INSTRUCTIONS = (
+    "Content turns sources (a URL, a file) into artifacts (video, audio, "
+    "subtitles, transcript, summary…). Typical flow: analyze_source to see what "
+    "a source is and what can be produced, then generate with the returned "
+    "analysis_id, then poll get_job until it is terminal and read its artifacts. "
+    "The engine names every artifact after the analyzed resource; when the "
+    "server's delivery policy is on (see get_config), finished files are also "
+    "copied into the server's media library and each artifact reports its "
+    "delivered_path there. An output spec may carry delivery "
+    '{"mode": "inherit|deliver|none", "folder": …, "filename": …} to steer this.'
+)
+
+
+def build_server(client: ContentClient | None = None) -> MCPServer:
+    client = client or ContentClient()
+    server = MCPServer(name="content", version="0.2.0", instructions=INSTRUCTIONS)
+
+    # --- tools (intention-level) ---------------------------------------------
+    @server.tool()
+    def analyze_source(url: str, credential: str | None = None) -> dict[str, Any]:
+        """Analyze a source URL: report what it is and what can be produced."""
+        return service.analyze_source(client, url, credential=credential)
+
+    @server.tool()
+    def list_capabilities(analysis_id: str) -> dict[str, Any]:
+        """Resolve the public capabilities available for an analyzed source."""
+        return service.list_capabilities(client, analysis_id)
+
+    @server.tool()
+    def generate(analysis_id: str, outputs: list[Any]) -> dict[str, Any]:
+        """Start a job producing the requested outputs from an analyzed source.
+        Each output is a type string ("audio") or a {type, options, ...} dict."""
+        return service.generate(client, analysis_id, outputs)
+
+    @server.tool()
+    def get_job(job_id: str) -> dict[str, Any]:
+        """Get a job's status and, once terminal, its produced artifacts."""
+        return service.get_job(client, job_id)
+
+    @server.tool()
+    def cancel_job(job_id: str) -> dict[str, Any]:
+        """Request cooperative cancellation of a running job."""
+        return service.cancel_job(client, job_id)
+
+    @server.tool()
+    def list_jobs(limit: int = 20) -> dict[str, Any]:
+        """List recent jobs (most recent first)."""
+        return service.list_jobs(client, limit)
+
+    @server.tool()
+    def get_artifact(artifact_id: str) -> dict[str, Any]:
+        """Artifact metadata; small text artifacts are inlined, larger/binary
+        ones return a download reference (never raw bytes over MCP)."""
+        return service.get_artifact(client, artifact_id)
+
+    @server.tool()
+    def get_config() -> dict[str, Any]:
+        """Server-side context for building requests: credential ids for
+        authenticated sources, whether delivery-by-default is on, and the
+        existing library folders."""
+        return service.get_config(client)
+
+    # --- resources (read-only, single content:// namespace) -------------------
+    @server.resource("content://analyses/{analysis_id}")
+    def analysis_resource(analysis_id: str) -> dict[str, Any]:
+        return service.analysis_resource(client, analysis_id)
+
+    @server.resource("content://jobs/{job_id}")
+    def job_resource(job_id: str) -> dict[str, Any]:
+        return service.job_resource(client, job_id)
+
+    @server.resource("content://artifacts/{artifact_id}")
+    def artifact_resource(artifact_id: str) -> dict[str, Any]:
+        return service.artifact_resource(client, artifact_id)
+
+    return server
+
+
+_HELP = """\
+content-mcp — the official MCP server for the Content engine (stdio).
+
+Run it from an MCP client, not by hand: the client spawns the process and
+speaks JSON-RPC over stdin/stdout. Configuration is one environment variable:
+
+  CONTENT_API_URL   base URL of your Content engine (default http://localhost:8010)
+
+Example client configuration:
+
+  {
+    "mcpServers": {
+      "content": {
+        "command": "content-mcp",
+        "env": { "CONTENT_API_URL": "http://localhost:8010" }
+      }
+    }
+  }
+
+Options:
+  --help      show this help and exit
+  --version   show the version and exit
+"""
+
+
+def main(argv: list[str] | None = None) -> None:
+    # A stdio MCP server owns stdout for JSON-RPC framing, so the only argv
+    # handling is the pair every tool owes its installer — and both exit
+    # before the transport starts. Anything else is a mistake worth stopping
+    # on (an MCP client passes no arguments).
+    import sys
+
+    args = sys.argv[1:] if argv is None else argv
+    if "--help" in args or "-h" in args:
+        print(_HELP, end="")
+        return
+    if "--version" in args:
+        # The wheel's own metadata, so `make version-update` has a single
+        # declaration to rewrite here (the MCPServer version= literal).
+        from importlib.metadata import PackageNotFoundError, version
+
+        try:
+            print(f"content-mcp {version('content-mcp')}")
+        except PackageNotFoundError:
+            print("content-mcp (uninstalled source tree)")
+        return
+    if args:
+        print(f"content-mcp: unexpected argument {args[0]!r} (try --help)")
+        raise SystemExit(2)
+    build_server().run("stdio")
+
+
+if __name__ == "__main__":
+    main()

content_mcp/service.py

@@ -0,0 +1,180 @@
+"""Intention-level operations over the Content SDK — the MCP server's logic.
+
+These pure functions take a ``content_sdk`` client and translate an agent's
+intent into SDK calls, returning plain JSON-able dicts. They contain **no** MCP
+types and **no** HTTP — the SDK is the only door to the engine. ``server.py``
+merely exposes them as MCP tools/resources.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from content_sdk import ContentClient, outputs
+
+# get_artifact never streams large binaries over MCP (refinement 6): only small
+# text artifacts are inlined; everything else returns metadata + a reference.
+MAX_INLINE_BYTES = 256 * 1024
+_INLINE_TEXT_TYPES = {"application/json", "application/x-subrip", "text/vtt"}
+
+
+def _is_inlineable_text(media_type: str) -> bool:
+    return media_type.startswith("text/") or media_type in _INLINE_TEXT_TYPES
+
+
+def _output_from_spec(spec: Any) -> dict[str, Any]:
+    """Accept a plain type string or a {type, options, from_sources, ...} dict."""
+    if isinstance(spec, str):
+        return outputs.output(spec)
+    return outputs.output(
+        spec["type"],
+        id=spec.get("id"),
+        from_sources=spec.get("from_sources"),
+        from_outputs=spec.get("from_outputs"),
+        scope=spec.get("scope"),
+        required=spec.get("required"),
+        # {mode, folder, filename} — where/how the artifact is delivered into
+        # the server library (ADR 0018); omitted = the server policy decides.
+        delivery=spec.get("delivery"),
+        options=spec.get("options"),
+    )
+
+
+# --- tools --------------------------------------------------------------------
+
+
+def analyze_source(
+    client: ContentClient, url: str, credential: str | None = None
+) -> dict[str, Any]:
+    """Analyze a URL and report what it is + what can be produced from it."""
+    analysis = client.analyze(outputs.url_source(url, credential_id=credential))
+    caps = client.get_capabilities(analysis.id)
+    entry = analysis.sources[0]
+    return {
+        "analysis_id": analysis.id,
+        "resource_type": entry.resource_type,
+        "title": entry.title,
+        "entries": len(entry.entries),
+        "capabilities": [
+            {"id": c.id, "status": c.status} for c in caps.sources[0].capabilities
+        ],
+    }
+
+
+def list_capabilities(client: ContentClient, analysis_id: str) -> dict[str, Any]:
+    """Resolve the public capabilities for a previously analyzed source."""
+    caps = client.get_capabilities(analysis_id)
+    src = caps.sources[0]
+    return {
+        "analysis_id": caps.analysis_id,
+        "source_id": src.source_id,
+        "capabilities": [
+            {"id": c.id, "status": c.status, "reason": c.reason}
+            for c in src.capabilities
+        ],
+    }
+
+
+def generate(
+    client: ContentClient, analysis_id: str, outputs_spec: list[Any]
+) -> dict[str, Any]:
+    """Start a generation job for an analyzed source. `outputs_spec` items are
+    either a type string ("audio") or a dict {type, options, ...}."""
+    job = client.generate(analysis_id, [_output_from_spec(s) for s in outputs_spec])
+    return {"job_id": job.id, "status": job.status}
+
+
+def get_job(client: ContentClient, job_id: str) -> dict[str, Any]:
+    """Job status; once terminal, the produced artifacts (metadata only)."""
+    job = client.get_job(job_id)
+    result: dict[str, Any] = {
+        "job_id": job.id,
+        "status": job.status,
+        "error": job.data.error,
+    }
+    if job.is_terminal:
+        result["artifacts"] = [
+            {
+                "id": a.id,
+                "type": a.type,
+                # The name to show a user (ADR 0017); the technical job-store
+                # name is an implementation detail agents don't need.
+                "filename": a.display_filename or a.filename,
+                # Where the file landed in the server's delivery library,
+                # relative to its root ("" = no delivered copy) — ADR 0018.
+                "delivered_path": a.delivered_path,
+                "media_type": a.media_type,
+                "size_bytes": a.size_bytes,
+            }
+            for a in client.artifacts(job_id)
+        ]
+    return result
+
+
+def cancel_job(client: ContentClient, job_id: str) -> dict[str, Any]:
+    """Request cooperative cancellation of a job."""
+    return client.cancel(job_id)
+
+
+def get_config(client: ContentClient) -> dict[str, Any]:
+    """What an agent needs to parameterize requests: the credential ids for
+    authenticated sources, whether artifacts are delivered into the server
+    library by default, and the existing library folders to choose from."""
+    config = client.config()
+    return {
+        "credentials": config.get("credentials", []),
+        "delivery_by_default": config.get("delivery", {}).get("by_default", False),
+        "folders": client.folders(),
+        "language": config.get("language", {}),
+    }
+
+
+def list_jobs(client: ContentClient, limit: int = 20) -> dict[str, Any]:
+    """Recent jobs (most recent first)."""
+    return {
+        "jobs": [
+            {"job_id": j.job_id, "status": j.status}
+            for j in client.list_jobs(limit=limit)
+        ]
+    }
+
+
+def get_artifact(client: ContentClient, artifact_id: str) -> dict[str, Any]:
+    """Artifact metadata; inline the content ONLY for small text artifacts,
+    otherwise return a download reference (never large binaries over MCP)."""
+    art = client.get_artifact(artifact_id)
+    meta = {
+        "id": art.id,
+        "type": art.type,
+        "filename": art.display_filename or art.filename,
+        "delivered_path": art.delivered_path,
+        "media_type": art.media_type,
+        "size_bytes": art.size_bytes,
+    }
+    if _is_inlineable_text(art.media_type) and art.size_bytes <= MAX_INLINE_BYTES:
+        text = client.artifact_bytes(artifact_id).decode("utf-8", errors="replace")
+        return {**meta, "inlined": True, "content": text}
+    return {
+        **meta,
+        "inlined": False,
+        "download_path": f"/api/v1/artifacts/{artifact_id}/content",
+        "note": (
+            f"not inlined (binary or larger than {MAX_INLINE_BYTES} bytes); "
+            "fetch the bytes via the API download path"
+        ),
+    }
+
+
+# --- resources (read-only JSON) -----------------------------------------------
+
+
+def analysis_resource(client: ContentClient, analysis_id: str) -> dict[str, Any]:
+    return client.get_analysis(analysis_id).data.model_dump()
+
+
+def job_resource(client: ContentClient, job_id: str) -> dict[str, Any]:
+    return client.get_job(job_id).data.model_dump()
+
+
+def artifact_resource(client: ContentClient, artifact_id: str) -> dict[str, Any]:
+    return client.get_artifact(artifact_id).model_dump()

content_mcp-0.2.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: content-mcp
+Version: 0.2.0
+Summary: Official MCP server for the Content engine (agentic facade over the SDK).
+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/apps/mcp/README.md
+Author: Yann Orieult
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+License-File: NOTICE
+Keywords: content,mcp,media,model-context-protocol,self-hosted
+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
+Requires-Dist: mcp>=1.2
+Description-Content-Type: text/markdown
+
+# `content-mcp` — Content MCP server
+
+The official **MCP server** for the Content engine: give Claude, an IDE or any
+MCP-compatible agent the ability to drive your Content instance — analyze a
+URL, generate video/audio/subtitles/transcripts, watch the job, land the files
+in your library. It is an agentic facade over the official
+[Python SDK](../../packages/python-sdk/README.md): **no REST of its own, no
+business logic**.
+
+```text
+any MCP client → content-mcp (this) → content_sdk → your Content engine (/api/v1)
+```
+
+## Install
+
+Once published, the server is an ordinary Python application — nothing to
+clone:
+
+```bash
+uv tool install content-mcp     # isolated, on your PATH — recommended
+content-mcp --help
+
+# or
+pipx install content-mcp
+```
+
+`content-mcp` 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_mcp-<version>-py3-none-any.whl` from the
+[latest release](https://github.com/LatentNoise/content/releases/latest), then:
+
+```bash
+uv tool install ./content_mcp-<version>-py3-none-any.whl \
+    --find-links .          # --find-links lets it resolve the SDK beside it
+```
+
+## Connect it to your engine
+
+One environment variable: `CONTENT_API_URL` (default `http://localhost:8010`).
+The server speaks stdio — your MCP client spawns it; you never run it by hand.
+
+### Claude Code
+
+```bash
+claude mcp add content --env CONTENT_API_URL=http://localhost:8010 -- content-mcp
+```
+
+### Claude Desktop, Cursor, and other clients
+
+Claude Desktop (`claude_desktop_config.json`), Cursor (`.cursor/mcp.json`) and
+any other client using the standard JSON shape:
+
+```json
+{
+  "mcpServers": {
+    "content": {
+      "command": "content-mcp",
+      "env": { "CONTENT_API_URL": "http://localhost:8010" }
+    }
+  }
+}
+```
+
+Then ask for something like *"analyze this YouTube URL and download the audio
+into my library"* — the expected flow is `get_config` → `analyze_source` →
+`generate` → `get_job`, ending with a `delivered_path` you can find under the
+engine's delivery folder.
+
+Logs go to **stderr** (stdout carries only the MCP JSON-RPC framing), so a
+client's log pane shows them without corrupting the session.
+
+## Tools (intention-level, not one-per-endpoint)
+
+| Tool | Intent |
+| --- | --- |
+| `analyze_source` | Analyze a URL: what it is + what can be produced |
+| `list_capabilities` | Resolve the capabilities for an analyzed source |
+| `generate` | Start a job producing outputs from an `analysis_id`; an output spec may carry `delivery` (`mode`/`folder`/`filename`, ADR 0018) |
+| `get_job` | Job status; once terminal, its artifacts — user-facing names (ADR 0017) and `delivered_path` in the server library |
+| `cancel_job` | Cooperative cancellation |
+| `list_jobs` | Recent jobs |
+| `get_artifact` | Artifact metadata; **small text is inlined**, larger/binary returns a download reference (never raw bytes over MCP) |
+| `get_config` | Request-building context: credential ids, whether delivery-by-default is on, the existing library folders |
+
+## Resources (read-only, `content://` namespace)
+
+`content://analyses/{id}`, `content://jobs/{id}`, `content://artifacts/{id}` —
+JSON views for a host to attach as context. Prompts are intentionally not
+provided yet.
+
+## For development
+
+From a clone:
+
+```bash
+make install    # editable installs of the engine, SDK, CLI and MCP in one venv
+claude mcp add content --env CONTENT_API_URL=http://localhost:8010 \
+  -- apps/backend/.venv/bin/python -m content_mcp.server
+```
+
+Build the distributions with `make wheels` (they land in `dist/`).
+
+## Verification status
+
+- Service logic over a mock transport: **verified** (`tests/test_service.py`).
+- The MCP wiring against the real `mcp` library (tools, resource templates):
+  **verified** (`tests/test_server.py`).
+- The full journey — MCP service → SDK → real FastAPI engine → executor →
+  delivery library, including `delivery` intent and `mode: "none"`:
+  **verified in-process** (`tests/test_end_to_end.py`, in `make validate`).
+- The installed wheel driven over stdio by an MCP client session against a
+  running engine: **verified** at packaging time (see the repository's
+  release notes); re-run it after any transport change.
+
+## Design
+
+- `service.py` — the intention logic; takes an SDK client, returns JSON. No MCP
+  imports, no HTTP. Fully unit-tested over a mock transport.
+- `server.py` — thin wiring: registers the tools/resources on an `MCPServer` and
+  runs stdio. `content-mcp` → `content_mcp.server:main`.
+- The layering is enforced by tests: the MCP server may import `content_sdk`
+  only — never an HTTP client, never backend internals
+  (`tests/test_layering.py` at the repo root).

content_mcp-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+content_mcp/__init__.py,sha256=406RG1jyKb3piNFlXO6-cs_U5iuUem9DXZkce-I1ZpE,161
+content_mcp/server.py,sha256=LN0tmqZkb2JscmyqB1S2B4FZfQGi326Q27IrzGQaOqc,5688
+content_mcp/service.py,sha256=TCHSMebEOZTiIdWJgkf7lRzkO8bgFKnKjRf6r-_3nFY,6684
+content_mcp-0.2.0.dist-info/METADATA,sha256=z7FvLTqL0VNKg5ki-sWqd-CK23OpCIpw5RkQxD-kklE,6142
+content_mcp-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+content_mcp-0.2.0.dist-info/entry_points.txt,sha256=Yw-FcOv634m3TAue3s2zbFUkJST-G9TncTwV-H_f1t4,56
+content_mcp-0.2.0.dist-info/licenses/LICENSE,sha256=UzbgYnVAKZ_x28AC54pY4P1QmwYSVhDF8QJu-WpfK6I,34522
+content_mcp-0.2.0.dist-info/licenses/NOTICE,sha256=0uIDSiuf2W9Uk6j45FqjuhiXV0uN6MaHmyX68La_kic,2816
+content_mcp-0.2.0.dist-info/RECORD,,

content_mcp-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_mcp-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+content-mcp = content_mcp.server:main

content_mcp-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_mcp-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.