prpr 1.0.0__tar.gz

prpr-1.0.0/.gitignore

@@ -0,0 +1,78 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Hatch / generated version file
+prpr/_version.py
+
+# Testing & coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+.hypothesis/
+
+# Type checking
+.mypy_cache/
+.ruff_cache/
+.pyre/
+.pytype/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project-local
+*.log
+.env
+.env.local
+scratch/
+local/
+
+# Vendor reference material — Blackmagic's DaVinci Resolve API doc and
+# anything else under reference/ stays local-only. Don't redistribute
+# upstream documentation through this repo.
+reference/
+
+# Docs
+site/
+
+# UXP developer-tools session artifacts (machine-specific)
+.uxprc

prpr-1.0.0/CHANGELOG.md

@@ -0,0 +1,148 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-07-10
+
+First stable release.
+
+### Added
+- Plugin freshness check: on connect, prpr compares the running bridge to
+  the version bundled in the pip package and (by default) UPIA-reinstalls
+  the newer one so a `pip install -U prpr` refreshes the in-Premiere bridge
+  on the next Premiere launch. Opt out with `PRPR_PLUGIN_AUTOUPDATE=0`;
+  surfaced in `prpr plugin check` and `prpr doctor --probe`.
+
+### Changed
+- Development status promoted to Production/Stable.
+- Packaging hardened for distribution: the headless plugin ships inside
+  the wheel (`prpr/plugin_assets/`); dev-tools session files are excluded.
+
+## [0.3.0] - 2026-07-10
+
+### Changed
+- **The bridge plugin is now headless.** It's a `command`-entrypoint UXP
+  plugin whose `main.js` opens the WebSocket connection at module load —
+  no panel to dock, no menu to click. A UPIA-installed command plugin runs
+  its code automatically at Premiere startup (verified on 26.5: connects
+  with no panel and no developer tools). Setup is now just `prpr plugin
+  install` + one Premiere restart; the bridge then starts with Premiere
+  every launch and reconnects on its own.
+- `prpr plugin autostart` → `prpr plugin check` (confirms the headless
+  bridge is connected). Install/doctor/error messages updated accordingly.
+
+### Added
+- `plugin-panel/` — the previous status-panel variant, kept for anyone who
+  wants a visible connection readout instead of the headless plugin.
+
+## [0.2.0] - 2026-07-10
+
+Live-validated against Adobe Premiere Pro 26.5. The full surface below was
+driven end-to-end through the bridge (`scripts/smoke_live.py` + targeted
+checks): transforms, keyframes, track mute/rename, marker move, keyframe
+listing, sequence clone/settings-write, color labels, bin rename, scratch
+disks, ingest, footage interpretation, selection read, still-frame and
+sequence export, FCPXML export, snapshot, spec.
+
+### Added
+- **Transforms & keyframes**: `effects.set_param` writes any component
+  parameter (Motion/Opacity/effect params) with `PointF`/`Color`
+  coercion; pass `at_seconds` to write a keyframe. `timeline.keyframes`
+  lists keyframe times for a parameter. (transforms + keyframes
+  live-validated)
+- **Timeline**: `track_update` (mute + rename), `clone`,
+  `create_subsequence`, `set_in_out`, `work_area` (26.5+),
+  `insert_mogrt`, `scene_edit_detection`, `move_marker`,
+  `create_from_media`, `selection` (read + clear — `setSelection`
+  crashes Premiere 26.5 beta and is refused rather than crashing the
+  host).
+- **Media**: `attach_proxy`, `create_subclip` (26.3+),
+  `transcript_export`/`transcript_import` (26.3+),
+  `footage_interpretation`, `color_label`, `bin_rename`, `smart_bin`,
+  `purge_cache` (26.5+), `selection`.
+- **Project**: `scratch_disks`, `ingest`, `color_settings`,
+  `import_sequences`, `import_ae_comps`, sequence `set_settings`. **App**:
+  `preference`.
+- **Host events**: `p.events.subscribe`/`on`/`off` (EventManager —
+  project/sequence/encoder/global events delivered to Python handlers on
+  the bridge thread).
+- **CLI/MCP** commands and tools for the above; `prpr/__main__.py`
+  (`python -m prpr`).
+- `scripts/smoke_live.py` full live E2E; `scripts/check_parity.py`
+  cross-repo status/key-symmetry check. mypy (strict) added to CI.
+- Parity matrix grown to 106 operations, synced with dvr.
+
+### Changed
+- Bridge object serialization depth 6 → 32 (nested inspect payloads).
+- Manifest `network.domains` → `"all"` (UXP 26.5 rejects explicit
+  `ws://` entries).
+- Daemon: `--wait`/`watch` commands forward through the daemon instead
+  of bypassing it (one-port-owner model), and the bypass parser no
+  longer mistakes an option value for the command.
+
+## [0.1.0] - 2026-07-10
+
+Initial release. Structural sibling of [dvr](https://github.com/mhadifilms/dvr) for Adobe Premiere Pro.
+
+### Added
+
+- **Bridge architecture**: bundled UXP panel (`prpr bridge`) that dials into a
+  local WebSocket server hosted by the Python side; generic RPC executor
+  (`call`/`get`/`set`/`eval`/`transaction`/`subscribe`) with an object-handle
+  registry, so the full `premierepro` API surface is reachable without plugin
+  updates. Live-validated against Premiere Pro 26.5.
+- **Python library** (`prpr.Premiere`) mirroring dvr's object model:
+  - `project`: list open projects, `ensure`/`create`/`load`/`save`/`delete`
+    (file-based, `PRPR_PROJECTS_DIR` convention)
+  - `timeline`: sequences with dvr's timeline routing — `list`/`current`/
+    `ensure`/`create`/`switch`/`delete`/`rename`, full `inspect()` (fps, frame
+    size, tracks, items, markers, settings), `append`/`insert`/`delete_clips`,
+    markers (add/list/remove with colors, durations, types), clip queries
+  - `media`: project-panel bins and clips — `inspect` tree, `import_` with
+    bin targeting, `bin_ensure` (nested paths), `move`, `find_or_import`,
+    plus Premiere-free `scan_media_files`
+  - `render`: `.epr` preset discovery, `submit` (immediate / queue-to-app /
+    queue-to-AME) with event-driven `wait`, still-frame export
+  - `effects`: catalogs (111 video effects, 106 transitions, 81 audio effects),
+    apply by matchName, transitions with duration/alignment, component-chain
+    inspection, and `set_param` for transforms/keyframes (Motion, Opacity, any
+    component parameter; PointF/Color coercion)
+  - `interchange`: FCPXML / OTIO / AAF sequence export
+  - XMP + project metadata read/write, source monitor control, per-project
+    properties store
+- **Declarative layer** mirroring dvr: `spec` (YAML/JSON apply with
+  plan/verify, `from_live` export), `diff` (timelines/spec/snapshot),
+  `snapshot` (capture/restore), `lint` (offline media, temp paths, empty
+  sequences)
+- **Daemon** (`prpr serve`): Unix-socket RPC holding the bridge across CLI
+  invocations, dvr wire format, full-CLI forwarding
+- **CLI** (`prpr`): dvr's command tree with identical output conventions
+  (json/table/yaml, `PRPR_FORMAT`, TTY auto-detection)
+- **MCP server** (`prpr mcp serve`): dvr's tool names and registration
+  pattern; typed tools for every library capability
+- **Cross-app parity contract**: `prpr.errors.NotSupportedError` for
+  operations Premiere's UXP API cannot perform (render queue enumeration,
+  page switching, interchange import, ...), each with cause/fix pointing to
+  the closest alternative; machine-readable matrix at `prpr schema show parity`
+- **Diagnostics**: `prpr doctor [--probe]` (install/plugin/port checks),
+  structured `PrprError` hierarchy with `cause`/`fix`/`state` on every failure
+- **Plugin management**: `prpr plugin install|uninstall|status` via Adobe's
+  UPIA installer with automatic `.ccx` packaging
+- Test suite (MockBridge at the wire boundary, no Premiere required)
+
+### Notes
+- `timeline.work_area` (WorkAreaUtils) is feature-detected — it is absent
+  on some Premiere 26.5 builds and fails with a clear version error rather
+  than crashing.
+- `Sequence.setSelection` crashes Premiere 26.5 beta, so `timeline.select`
+  supports read + clear only and refuses filtered selection.
+
+[1.0.0]: https://github.com/mhadifilms/prpr/releases/tag/v1.0.0
+[0.3.0]: https://github.com/mhadifilms/prpr/releases/tag/v0.3.0
+[0.2.0]: https://github.com/mhadifilms/prpr/releases/tag/v0.2.0
+[0.1.0]: https://github.com/mhadifilms/prpr/releases/tag/v0.1.0

prpr-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 M Hadi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prpr-1.0.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: prpr
+Version: 1.0.0
+Summary: Adobe Premiere Pro CLI, Python library, and MCP server. Automate editing, sequencing, and export with LLM-friendly tools for AI agents. Declarative, scriptable, structured JSON output.
+Project-URL: Homepage, https://github.com/mhadifilms/prpr
+Project-URL: Documentation, https://mhadifilms.github.io/prpr
+Project-URL: Repository, https://github.com/mhadifilms/prpr
+Project-URL: Issues, https://github.com/mhadifilms/prpr/issues
+Project-URL: Changelog, https://github.com/mhadifilms/prpr/blob/main/CHANGELOG.md
+Author-email: M Hadi <mhadifilms@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: adobe,ai-agents,automation,cli,command-line,llm,llm-tools,mcp,mcp-server,model-context-protocol,post-production,premiere-pro,rendering,uxp,vfx,video-editing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+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
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/mhadifilms/prpr/main/docs/assets/logo.svg" alt="prpr logo" width="140">
+</p>
+
+# prpr
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**The missing CLI, Python library, and MCP server for Adobe Premiere Pro.**
+
+Declarative. Scriptable. LLM-friendly. Structural sibling of [`dvr`](https://github.com/mhadifilms/dvr) (the same project for DaVinci Resolve) — same namespaces, same routing, same error model.
+
+`prpr` is a command-line tool, a typed Python library, and a [Model Context Protocol (MCP)](docs/mcp.md) server for automating **Adobe Premiere Pro** — editing, sequencing, effects, and export. It drives Premiere's UXP API through a bundled bridge plugin, wraps it in clean idempotent operations with structured JSON output, and makes it usable by humans, scripts, and AI agents (Claude, Cursor, and any MCP-compatible client).
+
+```bash
+pip install prpr
+```
+
+```bash
+$ prpr timeline inspect
+{
+  "name": "Edit_v1",
+  "fps": 23.976,
+  "duration_frames": 4274,
+  "frame_size": {"width": 1920, "height": 1080},
+  "tracks": {
+    "video": [{"index": 0, "name": "Video 1", "clips": 2, "items": [...]}],
+    "audio": [{"index": 0, "name": "Audio 1", "clips": 2, "items": [...]}]
+  },
+  "markers": [{"name": "start", "start": {"seconds": 1.0}, ...}]
+}
+```
+
+---
+
+## How it connects
+
+Premiere has no external scripting socket — its UXP API runs *inside* the app, and UXP plugins can only dial **out**. So `prpr` inverts the connection:
+
+```
+prpr CLI / library / MCP  ──hosts──▶  ws://127.0.0.1:8855  ◀──dials in──  prpr bridge panel (UXP, inside Premiere)
+```
+
+One-time setup:
+
+```bash
+prpr plugin install     # installs the headless bridge via Adobe's installer
+# restart Premiere once so it registers the plugin
+prpr doctor --probe     # verify the whole chain
+```
+
+The bridge is **headless** — a command-entrypoint UXP plugin that starts
+with Premiere automatically. There's no panel to open or keep open.
+
+## Why prpr exists
+
+Premiere's UXP API is powerful but locked inside the app:
+
+- **No external process access.** Resolve ships a Python API; Premiere gives you a JavaScript sandbox in a panel.
+- **Action/transaction ceremony.** Every mutation needs `lockedAccess` + `executeTransaction` + action objects.
+- **Ticks.** Time is measured in 254,016,000,000ths of a second.
+- **Silent failures.** `importFiles()` returns `false` and moves on with its day.
+- **No batch operators, no inspection.** You loop `getVideoTrack(i)` → `getTrackItems(...)` → six async getters per clip.
+
+`prpr` wraps all of it: one `inspect()` call returns full structured state, mutations are single undoable transactions, every failure decodes into an error with a `cause`, a `fix`, and a `state` snapshot.
+
+## Three ways to use it
+
+### 1. Python library
+
+```python
+from prpr import Premiere
+
+p = Premiere()                        # hosts the bridge, launches Premiere if needed
+
+p.project.ensure("MyShow")            # open-or-create ~/Documents/prpr Projects/MyShow.prproj
+p.media.import_(["/footage/a.mp4"], bin="Footage")
+
+tl = p.timeline.ensure("Edit_v1")
+tl.append("a.mp4")
+tl.add_marker(1.0, name="start", note="first pass", color_index=1)
+
+p.effects.set_param("Motion", "Scale", 50, clip_name="a.mp4")     # transforms
+p.effects.add_transition("ADBE Film Dissolve", clip_name="a.mp4")
+
+job = p.render.submit(target_dir="/exports", preset="prores-422", wait=True)
+print(job.output_path)
+```
+
+### 2. CLI
+
+```bash
+$ prpr project ensure MyShow
+$ prpr media import /footage/*.mp4 --bin Footage
+$ prpr timeline inspect | jq '.tracks.video[].items'
+$ prpr render submit --target-dir /exports --preset prores-422 --wait
+$ prpr apply spec.yaml            # terraform-style declarative reconcile
+```
+
+### 3. MCP server (for LLM agents)
+
+```bash
+$ prpr mcp install-claude     # one-shot Claude Desktop setup
+$ prpr mcp serve              # or run the stdio server yourself
+$ prpr mcp tools              # introspect the typed tools
+```
+
+## dvr ↔ prpr: one convention, two apps
+
+`prpr` and [`dvr`](https://github.com/mhadifilms/dvr) share naming, routing, output envelopes, and the error model. An agent (or human) that knows one knows the other:
+
+| | dvr (Resolve) | prpr (Premiere) |
+|---|---|---|
+| `timeline inspect` | ✅ | ✅ |
+| `media import --bin` | ✅ | ✅ |
+| `render submit --preset` | render presets | `.epr` presets |
+| `render queue` | ✅ | ❌ fails: `NotSupportedError` + fix |
+| `page edit` | ✅ | ❌ fails: `NotSupportedError` + fix |
+| `effects apply` | ❌ fails with pointer to Resolve alternative | ✅ |
+
+Operations one app can't perform **fail loudly** with a structured `NotSupportedError` explaining why and what to use instead — never silent degradation. The machine-readable support matrix ships in both packages:
+
+```bash
+$ prpr schema show parity | jq '.operations["render.queue"]'
+{"status": "dvr-only", "reason": "no enumerable render queue in UXP"}
+```
+
+## Requirements
+
+- Adobe Premiere Pro **25.6+** (26.x recommended; built and tested against 26.5)
+- Python 3.10+
+- macOS or Windows (daemon mode is macOS/Linux-style Unix sockets; Windows uses direct mode)
+
+## Documentation
+
+- [Getting started](docs/getting-started.md)
+- [Library guide](docs/library.md) · [CLI reference](docs/cli.md) · [MCP server](docs/mcp.md)
+- [Declarative specs](docs/spec.md) · [Daemon mode](docs/daemon.md)
+- [dvr ↔ prpr parity](docs/parity.md)
+
+## License
+
+MIT © M Hadi

prpr-1.0.0/README.md

@@ -0,0 +1,143 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/mhadifilms/prpr/main/docs/assets/logo.svg" alt="prpr logo" width="140">
+</p>
+
+# prpr
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**The missing CLI, Python library, and MCP server for Adobe Premiere Pro.**
+
+Declarative. Scriptable. LLM-friendly. Structural sibling of [`dvr`](https://github.com/mhadifilms/dvr) (the same project for DaVinci Resolve) — same namespaces, same routing, same error model.
+
+`prpr` is a command-line tool, a typed Python library, and a [Model Context Protocol (MCP)](docs/mcp.md) server for automating **Adobe Premiere Pro** — editing, sequencing, effects, and export. It drives Premiere's UXP API through a bundled bridge plugin, wraps it in clean idempotent operations with structured JSON output, and makes it usable by humans, scripts, and AI agents (Claude, Cursor, and any MCP-compatible client).
+
+```bash
+pip install prpr
+```
+
+```bash
+$ prpr timeline inspect
+{
+  "name": "Edit_v1",
+  "fps": 23.976,
+  "duration_frames": 4274,
+  "frame_size": {"width": 1920, "height": 1080},
+  "tracks": {
+    "video": [{"index": 0, "name": "Video 1", "clips": 2, "items": [...]}],
+    "audio": [{"index": 0, "name": "Audio 1", "clips": 2, "items": [...]}]
+  },
+  "markers": [{"name": "start", "start": {"seconds": 1.0}, ...}]
+}
+```
+
+---
+
+## How it connects
+
+Premiere has no external scripting socket — its UXP API runs *inside* the app, and UXP plugins can only dial **out**. So `prpr` inverts the connection:
+
+```
+prpr CLI / library / MCP  ──hosts──▶  ws://127.0.0.1:8855  ◀──dials in──  prpr bridge panel (UXP, inside Premiere)
+```
+
+One-time setup:
+
+```bash
+prpr plugin install     # installs the headless bridge via Adobe's installer
+# restart Premiere once so it registers the plugin
+prpr doctor --probe     # verify the whole chain
+```
+
+The bridge is **headless** — a command-entrypoint UXP plugin that starts
+with Premiere automatically. There's no panel to open or keep open.
+
+## Why prpr exists
+
+Premiere's UXP API is powerful but locked inside the app:
+
+- **No external process access.** Resolve ships a Python API; Premiere gives you a JavaScript sandbox in a panel.
+- **Action/transaction ceremony.** Every mutation needs `lockedAccess` + `executeTransaction` + action objects.
+- **Ticks.** Time is measured in 254,016,000,000ths of a second.
+- **Silent failures.** `importFiles()` returns `false` and moves on with its day.
+- **No batch operators, no inspection.** You loop `getVideoTrack(i)` → `getTrackItems(...)` → six async getters per clip.
+
+`prpr` wraps all of it: one `inspect()` call returns full structured state, mutations are single undoable transactions, every failure decodes into an error with a `cause`, a `fix`, and a `state` snapshot.
+
+## Three ways to use it
+
+### 1. Python library
+
+```python
+from prpr import Premiere
+
+p = Premiere()                        # hosts the bridge, launches Premiere if needed
+
+p.project.ensure("MyShow")            # open-or-create ~/Documents/prpr Projects/MyShow.prproj
+p.media.import_(["/footage/a.mp4"], bin="Footage")
+
+tl = p.timeline.ensure("Edit_v1")
+tl.append("a.mp4")
+tl.add_marker(1.0, name="start", note="first pass", color_index=1)
+
+p.effects.set_param("Motion", "Scale", 50, clip_name="a.mp4")     # transforms
+p.effects.add_transition("ADBE Film Dissolve", clip_name="a.mp4")
+
+job = p.render.submit(target_dir="/exports", preset="prores-422", wait=True)
+print(job.output_path)
+```
+
+### 2. CLI
+
+```bash
+$ prpr project ensure MyShow
+$ prpr media import /footage/*.mp4 --bin Footage
+$ prpr timeline inspect | jq '.tracks.video[].items'
+$ prpr render submit --target-dir /exports --preset prores-422 --wait
+$ prpr apply spec.yaml            # terraform-style declarative reconcile
+```
+
+### 3. MCP server (for LLM agents)
+
+```bash
+$ prpr mcp install-claude     # one-shot Claude Desktop setup
+$ prpr mcp serve              # or run the stdio server yourself
+$ prpr mcp tools              # introspect the typed tools
+```
+
+## dvr ↔ prpr: one convention, two apps
+
+`prpr` and [`dvr`](https://github.com/mhadifilms/dvr) share naming, routing, output envelopes, and the error model. An agent (or human) that knows one knows the other:
+
+| | dvr (Resolve) | prpr (Premiere) |
+|---|---|---|
+| `timeline inspect` | ✅ | ✅ |
+| `media import --bin` | ✅ | ✅ |
+| `render submit --preset` | render presets | `.epr` presets |
+| `render queue` | ✅ | ❌ fails: `NotSupportedError` + fix |
+| `page edit` | ✅ | ❌ fails: `NotSupportedError` + fix |
+| `effects apply` | ❌ fails with pointer to Resolve alternative | ✅ |
+
+Operations one app can't perform **fail loudly** with a structured `NotSupportedError` explaining why and what to use instead — never silent degradation. The machine-readable support matrix ships in both packages:
+
+```bash
+$ prpr schema show parity | jq '.operations["render.queue"]'
+{"status": "dvr-only", "reason": "no enumerable render queue in UXP"}
+```
+
+## Requirements
+
+- Adobe Premiere Pro **25.6+** (26.x recommended; built and tested against 26.5)
+- Python 3.10+
+- macOS or Windows (daemon mode is macOS/Linux-style Unix sockets; Windows uses direct mode)
+
+## Documentation
+
+- [Getting started](docs/getting-started.md)
+- [Library guide](docs/library.md) · [CLI reference](docs/cli.md) · [MCP server](docs/mcp.md)
+- [Declarative specs](docs/spec.md) · [Daemon mode](docs/daemon.md)
+- [dvr ↔ prpr parity](docs/parity.md)
+
+## License
+
+MIT © M Hadi

prpr-1.0.0/packaging/homebrew/README.md

@@ -0,0 +1,29 @@
+# Homebrew formula
+
+`prpr.rb` is the tap formula for [mhadifilms/homebrew-tap](https://github.com/mhadifilms/homebrew-tap),
+mirroring the `dvr` formula there.
+
+Homebrew's Python formulas vendor every dependency as a `resource` with a
+pinned sha256, and those are generated from the **published** sdist — so
+the formula is finalized right after the PyPI upload:
+
+```bash
+# 1. publish prpr to PyPI (see the release checklist), then:
+brew tap mhadifilms/tap
+cp packaging/homebrew/prpr.rb "$(brew --repository mhadifilms/tap)/Formula/prpr.rb"
+
+# 2. fill url + sha256 from the PyPI sdist
+#    (https://pypi.org/project/prpr/#files → tarball → "Copy SHA256")
+
+# 3. generate the resource stanzas (replaces the <<RESOURCES>> marker)
+brew update-python-resources "$(brew --repository mhadifilms/tap)/Formula/prpr.rb"
+
+# 4. verify, then commit to the tap
+brew install --build-from-source mhadifilms/tap/prpr
+brew test mhadifilms/tap/prpr
+brew audit --strict --online mhadifilms/tap/prpr
+```
+
+`mcp` is intentionally left out of the vendored resources (the CLI and
+library run without it); users who want the MCP server install via
+`pip install prpr`.