/**
 * Shared local-asset resolution helpers for every package that maps
 * composition asset URLs to files on disk (lint project rules, the HEVC
 * preview check, studio-server's media codec scan). Import via the
 * `@hyperframes/parsers/asset-resolution` subpath.
 */
declare function isRemoteOrInlineUrl(url: string): boolean;
/**
 * True when a URL still contains an unresolved templating placeholder —
 * `<<token>>`, `{{ token }}`, or `${token}` — that a build or templating step
 * substitutes before render. The static linter runs before that substitution,
 * so it cannot resolve such a value to a file on disk and must not report it as
 * a missing asset. Check the RAW url, before any `cleanAssetUrl()` step: that
 * splits on `?`/`#`, which also chops inside a `${...}` expression. (The `__UPPER__`
 * placeholder shape is combined with this in `isUnresolvedAssetPlaceholder` below, the
 * shared predicate asset-src sites skip on.)
 */
declare function hasUnresolvedTemplatingToken(url: string): boolean;
/**
 * True when an asset src is a build-time placeholder rather than a resolvable path:
 * the `__UPPER__` shape (e.g. `__DURATION__`) or an unresolved templating token
 * (`<<...>>`, `{{...}}`, `${...}`). Pass the RAW src, before any `cleanAssetUrl()` step —
 * cleanAssetUrl splits on `?`/`#`, which would chop inside a `${...}` expression and defeat
 * the token match. Remote/inline URL handling is deliberately NOT folded in: call sites
 * differ (e.g. audio uses a narrower http/data/blob check), so each keeps its own.
 *
 * This is the single skip predicate every asset-src lint / codec / compile site should
 * route through, so the placeholder rules can't drift apart across call sites.
 */
declare function isUnresolvedAssetPlaceholder(rawSrc: string): boolean;
/**
 * Every `data-composition-src` reference in one composition file's raw text, in
 * document order, deduped. The single owner of "which sub-compositions does
 * this file mount", so lint, telemetry, and any future scanner cannot drift
 * apart on the answer.
 *
 * Text-scanning rather than DOM-walking, and that is the load-bearing choice.
 * Every sub-composition except the render entry is authored inside a
 * `<template>` (the root index.html is forbidden from using that wrapper;
 * everything else prefers it). Template content is inert: it lives under
 * `template.content`, not the live document, so `document.querySelectorAll`
 * on a raw sub-composition file finds nothing and every nested reference
 * disappears. The renderer only gets away with a DOM scan because it recurses
 * on COMPILED html, where the wrapper is already gone.
 *
 * Callers must resolve each value against the PROJECT ROOT, never the
 * referencing file's directory: `data-composition-src` is root-relative at
 * every nesting level (see `parseSubCompositions` in htmlCompiler.ts).
 *
 * Comments, `<style>`, and `<script>` bodies are masked first so a
 * commented-out mount is not counted as a real one. Build-time placeholders and
 * remote or inline URLs are dropped: neither names a file on disk, and every
 * caller resolves what comes back against the project root.
 *
 * The scan walks tag by tag with `indexOf` rather than running one regex with
 * two open-ended `[^>]*` spans across the whole file. That shape is quadratic:
 * on input full of `<` with no `>`, every `<` starts a scan to end-of-string
 * that then backtracks, measured at 41ms / 165ms / 660ms / 2640ms for 10k /
 * 20k / 40k / 80k characters. This function runs on every render (via the
 * render plan), so a truncated download or a blob full of stray `<` would hang
 * the plan step before any video is produced. Bounding each regex to one
 * already-delimited tag makes the whole scan linear.
 */
declare function collectSubCompositionSrcs(html: string): string[];
declare function cleanAssetUrl(url: string): string;
declare function isWithinProjectRoot(projectDir: string, candidate: string): boolean;
declare function resolveLocalAssetCandidates(projectDir: string, url: string): string[];
declare function resolveExistingLocalAsset(projectDir: string, url: string): {
    resolved: string;
    rootRelativePath: string;
} | null;
/** Blanks out comments, `<style>`, and `<script>` bodies so tag-scanning
 * regexes don't false-positive on commented-out or scripted markup. */
declare function maskNonScannableRanges(html: string): string;

export { cleanAssetUrl, collectSubCompositionSrcs, hasUnresolvedTemplatingToken, isRemoteOrInlineUrl, isUnresolvedAssetPlaceholder, isWithinProjectRoot, maskNonScannableRanges, resolveExistingLocalAsset, resolveLocalAssetCandidates };