cox-protocol-package 1.0.2 → 1.2.0

package/scripts/check_distribution.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Check built artifacts themselves, including resource coverage and exclusions."""
+
+from __future__ import annotations
+import argparse
+import json
+import tarfile
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def check(dist: Path, vsix: Path):
+    version = json.loads((ROOT / "package.json").read_text())["version"]
+    with zipfile.ZipFile(
+        dist / f"cox_protocol_package-{version}-py3-none-any.whl"
+    ) as archive:
+        wheel = archive.namelist()
+        assert "cox_protocol/__main__.py" in wheel
+        assert (
+            len([name for name in wheel if name.startswith("cox_protocol/schemas/")])
+            == 5
+        )
+        assert "cox_protocol/starter/page/action_button/reference.svg" in wheel
+        assert not any(name.startswith("tools/") for name in wheel)
+        for name in wheel:
+            if name.startswith("cox_protocol/"):
+                assert archive.read(name) == (ROOT / name).read_bytes(), name
+    with tarfile.open(dist / f"cox_protocol_package-{version}.tar.gz") as archive:
+        source = archive.getnames()
+        assert any(name.endswith("/tests/test_compiler.py") for name in source)
+        assert any(name.endswith("/scripts/release_check.py") for name in source)
+    with tarfile.open(dist / f"cox-protocol-package-{version}.tgz") as archive:
+        npm = archive.getnames()
+        assert "package/cox_protocol/starter/manifest.cox" in npm
+        assert "package/bin/cox-protocol.js" in npm
+        assert (
+            json.load(archive.extractfile("package/package.json"))["version"] == version
+        )
+    with zipfile.ZipFile(vsix) as archive:
+        extension = archive.namelist()
+        package = json.loads(archive.read("extension/package.json"))
+        assert package["version"] == version
+        assert package["contributes"]["languages"][0]["id"] == "cox"
+        for item in package["contributes"]["snippets"]:
+            assert "extension/" + item["path"].removeprefix("./") in extension
+    for label, names in [
+        ("wheel", wheel),
+        ("sdist", source),
+        ("npm", npm),
+        ("VSIX", extension),
+    ]:
+        for name in names:
+            parts = Path(name).parts
+            assert not set(parts) & {
+                "node_modules",
+                "__pycache__",
+                ".git",
+                ".venv",
+                "build",
+            }, (label, name)
+            assert not name.endswith((".pyc", ".pyo", ".cox-build.json")), (label, name)
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "version": version,
+                "artifacts": ["wheel", "sdist", "npm", "VSIX"],
+                "checks": [
+                    "resources",
+                    "source-byte-match",
+                    "versions",
+                    "snippets",
+                    "no-transient-files",
+                ],
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dist", type=Path, required=True)
+    parser.add_argument("--vsix", type=Path, required=True)
+    args = parser.parse_args()
+    check(args.dist, args.vsix)

package/scripts/demo.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Record a real COX binding failure, correction and deterministic build."""
+
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+from cox_protocol.cox_lib import CoxError, compile_project, validate_project, write_json
+from cox_protocol.package_target import verify_archive
+from cox_protocol.scaffold import init_project
+
+
+def demo(out: Path):
+    out = out.resolve()
+    if out.exists() and any(out.iterdir()):
+        raise SystemExit("Use a new or empty demo output directory.")
+    out.mkdir(parents=True, exist_ok=True)
+    project = init_project(out / "project", "Contract Demo")
+    component = project / "page/action_button/action_button.cox"
+    corrected = component.read_text()
+    invalid = corrected.replace("Slug: action_button", "Slug: action_buton")
+    component.write_text(invalid)
+    try:
+        validate_project(project)
+    except CoxError as exc:
+        diagnostic = exc.as_dict()
+    else:
+        raise RuntimeError("Expected the broken binding to fail")
+    finally:
+        component.write_text(corrected)
+    (out / "01-invalid-component.cox.txt").write_text(invalid)
+    write_json(out / "02-diagnostic.json", diagnostic)
+    (out / "03-corrected-component.cox.txt").write_text(corrected)
+    summary = validate_project(project)
+    build = compile_project(project, out / "build", ["all"], strict=True)
+    verified = verify_archive(build["target_results"]["package"]["archive"])
+    verified["archive"] = Path(verified["archive"]).relative_to(out).as_posix()
+    evidence = {
+        "ok": True,
+        "rule": "Each component Slug must match its manifest binding.",
+        "observedDiagnostic": diagnostic,
+        "correction": "action_buton → action_button",
+        "validatedDocuments": len(summary.documents),
+        "archive": verified,
+        "scope": "Contract validation and structural React scaffolding; no rendered UI or AST compliance evaluation.",
+    }
+    write_json(out / "04-result.json", evidence)
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "output": str(out),
+                "validatedDocuments": len(summary.documents),
+            }
+        )
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out", required=True, type=Path)
+    demo(parser.parse_args().out)

package/scripts/package-vscode.mjs

@@ -0,0 +1,12 @@
+import { mkdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const extension = path.join(root, 'editor-support/vscode');
+const version = JSON.parse(readFileSync(path.join(extension, 'package.json'), 'utf8')).version;
+const destination = process.argv[2] ? path.resolve(process.argv[2]) : path.join(root, 'build/vscode', `cox-language-support-${version}.vsix`);
+mkdirSync(path.dirname(destination), { recursive: true });
+const result = spawnSync(process.execPath, [path.join(root, 'node_modules/@vscode/vsce/vsce'), 'package', '--no-dependencies', '--out', destination], { cwd: extension, stdio: 'inherit' });
+if (result.error) console.error(result.error.message);
+process.exit(result.status ?? 1);

package/scripts/release_check.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Exercise an installed CLI away from its checkout; no repository imports."""
+
+from __future__ import annotations
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def check(command, env=None):
+    with tempfile.TemporaryDirectory(prefix="cox-installed-") as raw:
+        root = Path(raw)
+
+        def run(*args, expected=0):
+            result = subprocess.run(
+                [*command, *args], cwd=root, env=env, capture_output=True, text=True
+            )
+            if result.returncode != expected:
+                raise RuntimeError(
+                    f"{args}: exit {result.returncode}\n{result.stdout}\n{result.stderr}"
+                )
+            return result.stdout
+
+        version = run("--version").strip()
+        assert json.loads(run("init", "demo", "--json"))["ok"]
+        assert (
+            json.loads(run("validate", "demo", "--json", "--strict"))["documentCount"]
+            == 3
+        )
+        component = root / "demo/page/action_button/action_button.cox"
+        original = component.read_text()
+        component.write_text(
+            original.replace("Slug: action_button", "Slug: action_buton")
+        )
+        invalid = json.loads(run("validate", "demo", "--json", expected=1))
+        assert invalid["errors"][0]["code"] == "BINDING_MISMATCH"
+        component.write_text(original)
+        result = json.loads(
+            run(
+                "compile",
+                "demo",
+                "--target",
+                "all",
+                "--out",
+                str(root / "artifacts"),
+                "--json",
+                "--strict",
+            )
+        )
+        archive = Path(result["target_results"]["package"]["archive"])
+        assert json.loads(run("verify-package", str(archive), "--json"))["ok"]
+        print(
+            json.dumps(
+                {
+                    "ok": True,
+                    "version": version,
+                    "command": command,
+                    "checks": [
+                        "init",
+                        "strict validation",
+                        "invalid binding diagnostic",
+                        "corrected all-target compile",
+                        "external output",
+                        "archive verification",
+                    ],
+                }
+            )
+        )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--python", default=sys.executable)
+    parser.add_argument("--node-cli", type=Path)
+    args = parser.parse_args()
+    if args.node_cli:
+        check(
+            ["node", str(args.node_cli.resolve())],
+            {**os.environ, "COX_PYTHON": args.python},
+        )
+    else:
+        check([args.python, "-m", "cox_protocol"])

package/tests/conftest.py

@@ -0,0 +1,21 @@
+import shutil
+from pathlib import Path
+import pytest
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+@pytest.fixture
+def project(tmp_path):
+    folder = tmp_path / "source"
+    shutil.copytree(ROOT / "examples" / "quickstart", folder)
+    return folder
+
+
+def change(project, rel, mutate):
+    path = project / rel
+    doc = yaml.safe_load(path.read_text())
+    mutate(doc)
+    path.write_text(yaml.safe_dump(doc, sort_keys=False))
+    return doc

package/tests/test_cli_and_typescript.py

@@ -0,0 +1,123 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import pytest
+from typer.testing import CliRunner
+from cox_protocol import __version__
+from cox_protocol.cox_cli import app
+from cox_protocol.cox_lib import compile_project, schema_issues
+from conftest import ROOT, change
+
+
+def test_version_and_snippets():
+    assert CliRunner().invoke(app, ["--version"]).output.strip() == __version__
+    assert json.loads((ROOT / "package.json").read_text())["version"] == __version__
+    assert (
+        json.loads((ROOT / "editor-support/vscode/package.json").read_text())["version"]
+        == __version__
+    )
+    assert f'version = "{__version__}"' in (ROOT / "pyproject.toml").read_text()
+    import yaml
+
+    for path in (ROOT / "editor-support/vscode/snippets").glob("cox-*.json"):
+        if path.name == "cox-common.json":
+            continue
+        for snippet in json.loads(path.read_text()).values():
+            body = "\n".join(snippet["body"])
+            body = re.sub(r"\$\{\d+:([^}]+)\}", r"\1", body)
+            body = re.sub(r"\$\{\d+\|([^,|]+)[^}]*\|\}", r"\1", body)
+            assert not schema_issues(yaml.safe_load(body), path), path
+
+
+def test_node_wrapper_cwd_isolation_and_errors(project, tmp_path):
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("Node integration runs in the release/CI environment")
+    for name in ("yaml.py", "cox_protocol.py", "jsonschema.py"):
+        (project / name).write_text(
+            'raise RuntimeError("Caller module must not be imported")'
+        )
+    env = {**os.environ, "COX_PYTHON": sys.executable}
+    wrapper = ROOT / "bin/cox-protocol.js"
+    version = subprocess.run(
+        [node, str(wrapper), "--version"],
+        capture_output=True,
+        text=True,
+        env=env,
+        cwd=project,
+    )
+    assert version.returncode == 0 and version.stdout.strip() == __version__
+    result = subprocess.run(
+        [node, str(wrapper), "validate", ".", "--json"],
+        capture_output=True,
+        text=True,
+        env=env,
+        cwd=project,
+    )
+    assert result.returncode == 0, result.stderr
+    assert json.loads(result.stdout)["ok"] is True
+    change(project, "manifest.cox", lambda d: d.update(CoxVersion="unknown"))
+    bad = subprocess.run(
+        [node, str(wrapper), "validate", ".", "--json"],
+        capture_output=True,
+        text=True,
+        env=env,
+        cwd=project,
+    )
+    assert bad.returncode == 1
+    assert json.loads(bad.stdout)["errors"]
+    missing = subprocess.run(
+        [node, str(wrapper), "--help"],
+        capture_output=True,
+        text=True,
+        env={**env, "COX_PYTHON": str(tmp_path / "absent")},
+    )
+    assert missing.returncode == 1 and "COX needs Python" in missing.stderr
+
+
+def test_generated_tsx_typechecks(project, tmp_path):
+    tsc = ROOT / "node_modules/typescript/bin/tsc"
+    if not tsc.exists():
+        if os.environ.get("COX_REQUIRE_TYPESCRIPT") == "1":
+            pytest.fail("npm ci is required before this gate")
+        pytest.skip("Run npm ci to enable the TypeScript release gate")
+    change(
+        project,
+        "page/action_button/action_button.cox",
+        lambda d: d.update(
+            Role='Quoted "role" </section> */\nnext line',
+            ImplementationHints=["*/\nexport const wrong = 1"],
+        ),
+    )
+    out = tmp_path / "consumer"
+    compile_project(project, out, ["react"])
+    (out / "node_modules").symlink_to(ROOT / "node_modules", target_is_directory=True)
+    (out / "tsconfig.json").write_text(
+        json.dumps(
+            {
+                "compilerOptions": {
+                    "strict": True,
+                    "noEmit": True,
+                    "jsx": "react-jsx",
+                    "target": "ES2020",
+                    "module": "ESNext",
+                    "moduleResolution": "Bundler",
+                    "skipLibCheck": True,
+                },
+                "include": ["react/**/*.ts", "react/**/*.tsx"],
+            }
+        )
+    )
+    checked = subprocess.run(
+        ["node", str(tsc), "--project", str(out / "tsconfig.json")],
+        capture_output=True,
+        text=True,
+    )
+    assert checked.returncode == 0, checked.stdout + checked.stderr
+    assert (
+        "EvidenceSummary.Intended:"
+        in (out / "react/components/ActionButton/index.tsx").read_text()
+    )

package/tests/test_compiler.py

@@ -0,0 +1,279 @@
+import json
+import shutil
+import stat
+import zipfile
+import pytest
+from cox_protocol.cox_lib import CoxError, compile_project, validate_project
+from cox_protocol.compiler import MARKER
+from cox_protocol.package_target import verify_archive, zip_write_bytes
+from conftest import change
+
+
+def tree(root):
+    return {
+        p.relative_to(root).as_posix(): p.read_bytes()
+        for p in root.rglob("*")
+        if p.is_file()
+    }
+
+
+def test_deterministic_external_build_and_roundtrip(project, tmp_path):
+    first = tmp_path / "one"
+    second = tmp_path / "two"
+    compile_project(project, first, ["all"])
+    copy = tmp_path / "renamed-checkout"
+    shutil.copytree(project, copy)
+    compile_project(copy, second, ["package", "react,json"])
+    assert tree(first) == tree(second)
+    archive = next((first / "package").glob("*.zip"))
+    verified = verify_archive(archive)
+    with zipfile.ZipFile(archive) as z:
+        names = z.namelist()
+        assert names == sorted(names)
+        assert all(i.date_time == (1980, 1, 1, 0, 0, 0) for i in z.infolist())
+        assert any(n.endswith("/build/manifest.compiled.json") for n in names)
+        assert any(n.endswith("/build/reports/verification_report.json") for n in names)
+        assert not any(
+            str(tmp_path) in z.read(n).decode("utf-8", errors="ignore") for n in names
+        )
+        z.extractall(tmp_path / "unpacked")
+    assert verified["fileCount"] == len(names) - 1
+    assert len(validate_project(tmp_path / "unpacked/cox_example").documents) == 3
+
+
+def test_recompile_ownership_and_removed_target(project, tmp_path):
+    out = tmp_path / "out"
+    compile_project(project, out, ["all"])
+    (out / "user-notes.txt").write_text("preserve me")
+    compile_project(project, out, ["json"])
+    assert not list((out / "react").rglob("*.tsx"))
+    assert not list((out / "package").glob("*.zip"))
+    assert (out / "user-notes.txt").read_text() == "preserve me"
+    owned = out / "normalized/page/page.json"
+    owned.write_text("edited by human")
+    before = tree(out)
+    with pytest.raises(CoxError) as exc:
+        compile_project(project, out, ["all"])
+    assert exc.value.issues[0].code == "OUTPUT_MODIFIED"
+    assert tree(out) == before
+
+
+def test_unowned_collision_and_output_boundaries(project, tmp_path):
+    out = tmp_path / "collision"
+    out.mkdir()
+    (out / "manifest.compiled.json").write_text("keep")
+    with pytest.raises(CoxError):
+        compile_project(project, out, ["all"])
+    assert tree(out) == {"manifest.compiled.json": b"keep"}
+    for path in [project, project.parent, project / "page"]:
+        with pytest.raises(CoxError):
+            compile_project(project, path, ["json"])
+    (tmp_path / "link").symlink_to(out, target_is_directory=True)
+    with pytest.raises(CoxError):
+        compile_project(project, tmp_path / "link", ["json"])
+
+
+@pytest.mark.parametrize(
+    "raw", ["../victim", "/tmp/victim", "./victim", "a//b", "C:/victim"]
+)
+def test_invalid_ownership_marker(project, tmp_path, raw):
+    out = tmp_path / "out"
+    out.mkdir()
+    (out / MARKER).write_text(
+        json.dumps({"format": "cox-build/1", "files": {raw: "0" * 64}})
+    )
+    with pytest.raises(CoxError):
+        compile_project(project, out, ["json"])
+
+
+def test_publish_rolls_back_io_failure(project, tmp_path, monkeypatch):
+    import cox_protocol.compiler as compiler
+
+    out = tmp_path / "out"
+    compile_project(project, out, ["json"])
+    before = tree(out)
+    change(project, "page/page.cox", lambda d: d["Layout"].update(Desktop="Changed"))
+    original = compiler.os.replace
+    calls = 0
+
+    def replace(source, dest):
+        nonlocal calls
+        calls += 1
+        if calls == 2:
+            raise OSError("simulated full disk")
+        return original(source, dest)
+
+    monkeypatch.setattr(compiler.os, "replace", replace)
+    with pytest.raises(CoxError):
+        compile_project(project, out, ["all"])
+    assert tree(out) == before
+
+
+def test_stale_files_not_packaged(project, tmp_path):
+    out = project / "build"
+    compile_project(project, out, ["all"])
+    (out / "stale.txt").write_text("never ship")
+    compile_project(project, out, ["package"])
+    with zipfile.ZipFile(next((out / "package").glob("*.zip"))) as z:
+        assert not any("stale.txt" in n or "/react/" in n for n in z.namelist())
+
+
+def test_package_excludes_env_and_explicit_transient(project, tmp_path):
+    assets = project / "assets"
+    assets.mkdir()
+    (assets / "readme").write_text("asset")
+    (assets / ".env").write_text("not an input")
+    change(project, "manifest.cox", lambda d: d.update(ToolingFiles=["assets"]))
+    compile_project(project, tmp_path / "out", ["package"])
+    with zipfile.ZipFile(next((tmp_path / "out/package").glob("*.zip"))) as z:
+        assert not any(n.endswith(".env") for n in z.namelist())
+    change(project, "manifest.cox", lambda d: d.update(ToolingFiles=["assets/.env"]))
+    with pytest.raises(CoxError):
+        compile_project(project, tmp_path / "bad", ["package"])
+
+
+@pytest.mark.parametrize(
+    "filename", ["invalid:name.txt", "back\\slash.txt", "CON.txt", "trailing."]
+)
+def test_package_rejects_nonportable_files_in_referenced_directory(
+    project, tmp_path, filename
+):
+    assets = project / "assets"
+    assets.mkdir()
+    (assets / filename).write_text("not portable")
+    change(project, "manifest.cox", lambda d: d.update(ToolingFiles=["assets"]))
+    out = tmp_path / "out"
+    with pytest.raises(CoxError) as exc:
+        compile_project(project, out, ["package"])
+    assert exc.value.issues[0].code == "PACKAGE_PATH"
+    assert not out.exists()
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        "tamper",
+        "extra",
+        "duplicate",
+        "traversal",
+        "manifest",
+        "inventory_symlink",
+        "payload_symlink",
+    ],
+)
+def test_archive_tampering_is_rejected(project, tmp_path, mutation):
+    compile_project(project, tmp_path / "out", ["all"])
+    original = next((tmp_path / "out/package").glob("*.zip"))
+    bad = tmp_path / "bad.zip"
+    with zipfile.ZipFile(original) as source, zipfile.ZipFile(bad, "w") as dest:
+        for index, info in enumerate(source.infolist()):
+            data = source.read(info.filename)
+            if mutation == "tamper" and index == 0:
+                data += b"tampered"
+            if mutation == "manifest" and info.filename.endswith(
+                "/package.manifest.json"
+            ):
+                data = b"{}"
+            if (
+                mutation == "inventory_symlink"
+                and info.filename.endswith("/package.manifest.json")
+            ) or (mutation == "payload_symlink" and index == 0):
+                info.external_attr = (stat.S_IFLNK | 0o644) << 16
+            dest.writestr(info, data)
+        if mutation == "extra":
+            zip_write_bytes(dest, "cox_example/extra", b"extra")
+        if mutation == "traversal":
+            zip_write_bytes(dest, "cox_example/../outside", b"outside")
+        if mutation == "duplicate":
+            with pytest.warns(UserWarning):
+                dest.writestr(source.infolist()[0], b"duplicate")
+    with pytest.raises(CoxError):
+        verify_archive(bad)
+
+
+def test_react_adversarial_prose_and_numeric_slug(project, tmp_path):
+    change(
+        project,
+        "manifest.cox",
+        lambda d: d["Pages"][0]["Components"][0].update(Slug="123_button"),
+    )
+    change(
+        project,
+        "page/page.cox",
+        lambda d: d["Children"]["Components"][0].update(Slug="123_button"),
+    )
+    change(
+        project,
+        "page/action_button/action_button.cox",
+        lambda d: d.update(Slug="123_button", Role='a "quote" </section> */\nalert(1)'),
+    )
+    out = tmp_path / "out"
+    compile_project(project, out, ["react"])
+    result = (out / "react/components/Cox123Button/index.tsx").read_text()
+    assert "export function Cox123Button" in result
+    assert 'aria-label={"a \\"quote\\"' in result
+    assert "* /" in result
+
+
+def test_react_collision_is_actionable(project, tmp_path):
+    component = project / "page/action_button"
+    shutil.copytree(component, project / "page/other")
+    change(
+        project, "page/other/action_button.cox", lambda d: d.update(Slug="example_page")
+    )
+    change(
+        project,
+        "manifest.cox",
+        lambda d: d["Pages"][0]["Components"].append(
+            {
+                "Slug": "example_page",
+                "Folder": "page/other",
+                "ComponentInstruction": "page/other/action_button.cox",
+                "ComponentScreenshotPlaceholder": "page/other/reference.svg",
+            }
+        ),
+    )
+    change(
+        project,
+        "page/page.cox",
+        lambda d: d["Children"]["Components"].append(
+            {"Slug": "example_page", "Folder": "other", "Role": "Other"}
+        ),
+    )
+    with pytest.raises(CoxError) as exc:
+        compile_project(project, tmp_path / "out", ["react"])
+    assert exc.value.issues[0].code == "REACT_COLLISION"
+
+
+def test_modified_marker_or_nested_output_symlink_preserves_files(project, tmp_path):
+    out = tmp_path / "out"
+    compile_project(project, out, ["json"])
+    other = tmp_path / "elsewhere"
+    other.mkdir()
+    shutil.rmtree(out / "normalized")
+    (out / "normalized").symlink_to(other, target_is_directory=True)
+    with pytest.raises(CoxError):
+        compile_project(project, out, ["json"])
+    assert not list(other.iterdir())
+
+
+def test_unknown_target_does_not_create_outputs(project, tmp_path):
+    out = tmp_path / "out"
+    with pytest.raises(CoxError) as exc:
+        compile_project(project, out, ["all,unknown"])
+    assert exc.value.issues[0].code == "TARGET_UNKNOWN"
+    assert not out.exists()
+
+
+def test_output_parent_alias_is_canonicalized_before_overlap_check(project, tmp_path):
+    actual = tmp_path / "actual"
+    actual.mkdir()
+    alias = tmp_path / "alias"
+    alias.symlink_to(actual, target_is_directory=True)
+    result = compile_project(project, alias / "output", ["json"])
+    assert result["build_root"] == actual / "output"
+    assert (actual / "output/manifest.compiled.json").exists()
+    project_alias = tmp_path / "project-alias"
+    project_alias.symlink_to(project, target_is_directory=True)
+    with pytest.raises(CoxError):
+        compile_project(project, project_alias / "page", ["json"])