}
 
            if (static::$useFaceDetection && extension_loaded('facedetect')) {
                Cache::store($cacheKey, time());
                set_time_limit(static::$faceDetectionTimeLimit);
 
                $cropper = new CropFace($this->FilesystemPath);
            } else {
                $cropper = new stojg\crop\CropEntropy($this->FilesystemPath);
            }
 
            $croppedImage = $cropper->resizeAndCrop($thumbWidth, $thumbHeight);
 
            $croppedImage->writeimage($thumbPath);
 
            set_time_limit($originalTimeLimit);
            Cache::delete($cacheKey);
        } else {
            // load source image
            $srcImage = $this->getImage();
            $srcWidth = imagesx($srcImage);
            $srcHeight = imagesy($srcImage);
 
            // calculate
            if ($srcWidth && $srcHeight) {
                $widthRatio = ($srcWidth > $maxWidth) ? ($maxWidth / $srcWidth) : 1;
                $heightRatio = ($srcHeight > $maxHeight) ? ($maxHeight / $srcHeight) : 1;
 
                // crop width/height to scale size if fill disabled
                if ($cropped) {
                    $ratio = max($widthRatio, $heightRatio);
                } else {
                    $ratio = min($widthRatio, $heightRatio);
                }
 
                $scaledWidth = round($srcWidth * $ratio);
                $scaledHeight = round($srcHeight * $ratio);
            } else {
                $scaledWidth = $maxWidth;
                $scaledHeight = $maxHeight;

        if ($fillColor) {
            $thumbFormat .= 'x'.strtoupper($fillColor);
        }
 
        if ($cropped) {
            $thumbFormat .= '.cropped';
        }
 
        $thumbPath = Site::$rootPath.'/site-data/media/'.$thumbFormat.'/'.$this->Filename;
 
        // look for cached thumbnail
        if (!file_exists($thumbPath)) {
            // ensure directory exists
            $thumbDir = dirname($thumbPath);
            if (!is_dir($thumbDir)) {
                mkdir($thumbDir, static::$newDirectoryPermissions, true);
            }
 
            // create new thumbnail
            $this->createThumbnailImage($thumbPath, $maxWidth, $maxHeight, $fillColor, $cropped);
        }
 
 
        // return path
        return $thumbPath;
    }
 
    public function createThumbnailImage($thumbPath, $maxWidth, $maxHeight, $fillColor = false, $cropped = false)
    {
        $thumbWidth = $maxWidth;
        $thumbHeight = $maxHeight;
 
        if ($cropped && extension_loaded('imagick') && $this->FilesystemPath) {
            $originalTimeLimit = ini_get('max_execution_time');
 
            // check for existing facedetect job
            $cacheKey = "facedetect:{$thumbPath}";
            $faceDetectTime = Cache::fetch($cacheKey);
 
            // a parallel or dead worker is already working on this thumb

            static::shiftPath();
            $maxWidth = $matches[1];
            $maxHeight = $matches[2];
            $fillColor = !empty($matches[4]) ? $matches[4] : false;
        } else {
            $maxWidth = static::$defaultThumbnailWidth;
            $maxHeight = static::$defaultThumbnailHeight;
            $fillColor = false;
        }
 
        if (static::peekPath() == 'cropped') {
            static::shiftPath();
            $cropped = true;
        } else {
            $cropped = false;
        }
 
 
        // fetch thumbnail
        $thumbPath = $Media->getThumbnail($maxWidth, $maxHeight, $fillColor, $cropped);
 
 
        // dump it out
        header("ETag: media-$Media->ID-$maxWidth-$maxHeight-$fillColor-$cropped");
        header("Content-Type: $Media->ThumbnailMIMEType");
        header('Content-Length: '.filesize($thumbPath));
        readfile($thumbPath);
        exit();
    }
 
 
 
    public static function handleManageRequest()
    {
        // access control
        $GLOBALS['Session']->requireAccountLevel('Staff');
 
        return static::respond('manage');
    }
 

<?php
 
// invoke request handler
MediaRequestHandler::handleThumbnailRequest();
 

            if (!empty($GLOBALS['Session'])) {
                newrelic_add_custom_parameter('session.token', $GLOBALS['Session']->Handle);
                newrelic_add_custom_parameter('session.person_id', $GLOBALS['Session']->PersonID);
            }
 
            newrelic_add_custom_parameter('script_path', $_SCRIPT_NODE->FullPath);
        }
 
        if (is_callable(static::$onBeforeScriptExecute)) {
            call_user_func(static::$onBeforeScriptExecute, $_SCRIPT_NODE);
        }
 
        if (class_exists('Emergence\\EventBus')) {
            Emergence\EventBus::fireEvent('beforeScriptExecute', 'Site', array(
                'node' => $_SCRIPT_NODE,
                'exit' => $_SCRIPT_EXIT
            ));
        }
 
        require($_SCRIPT_NODE->RealPath);
 
        if ($_SCRIPT_EXIT) {
            exit();
        }
    }
 
    public static function resolvePath($path, $checkParent = true, $checkCache = true)
    {
        // special case: request for root collection
        if (is_string($path) && (empty($path) || $path == '/')) {
            return new Emergence\DAV\RootCollection();
        }
 
        // parse path
        if (is_array($path)) {
            $path = implode('/', $path);
        }
 
        // retrieve from filesystem
        $fs = static::getFilesystem();

            ));
        }
 
        // if resolved node is a collection, look for _index.php
        if (is_a(static::$resolvedNode, 'SiteCollection')) {
            $indexNode = static::resolvePath(array_merge($pathResult['searchPath'], array('_index.php')));
 
            if ($indexNode) {
                // switch resolvedNode to the index script
                static::$resolvedNode = $indexNode;
            } elseif (!static::$listCollections) {
                // if listing collections is disabled and no index script was found, treat this as not found
                return static::respondNotFound();
            }
        }
 
        // handle php script
        if (static::$resolvedNode->MIMEType == 'application/php') {
            // TODO: execute _all.php handlers, cache the list of them for the containing collection
            return static::executeScript(static::$resolvedNode);
        }
 
        // output response
        if (is_callable(array(static::$resolvedNode, 'outputAsResponse'))) {
            if (is_callable(static::$onBeforeStaticResponse)) {
                call_user_func(static::$onBeforeStaticResponse, static::$resolvedNode);
            }
 
            if (class_exists('Emergence\\EventBus')) {
                Emergence\EventBus::fireEvent('beforeStaticResponse', 'Site', array(
                    'node' => static::$resolvedNode
                ));
            }
 
            static::$resolvedNode->outputAsResponse();
        }
 
        // fallback on notfound handler
        return static::respondNotFound();
    }

        'root' => '/tmp/logs',
    ],
 
    'storage' => [
        // Media: one fleet-wide GCS bucket is mounted read-write at /media
        // (Cloud Run gcsfuse volume, see the tofu cloud-run-site module),
        // holding per-site prefixes {ARCHIVE_HOST}/{handle}/ — populated only
        // for sites with qualifying media (rows not attached to a developer's
        // profile photo). If this site's prefix exists, root the framework's
        // local storage there so MediaRequestHandler serves real originals
        // and thumbnails (and can generate thumbnail variants back into the
        // bucket); otherwise fall back to disposable tmpfs scratch — a
        // no-media site needs no bucket prefix and costs nothing.
        'local_root' => is_dir($mediaDir = '/media/'.(getenv('ARCHIVE_HOST') ?: 'unknown-host')."/{$siteHandle}")
            ? $mediaDir
            : "/tmp/data/{$siteHandle}",
    ],
]);
 
Site::handleRequest();