@pipedog/core 0.0.0 → 0.2.0

package/dist/utils/deprecation.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/deprecation.py
+/**
+ * Deprecation marker conventions for the Pipecat framework.
+ *
+ * Every deprecation is emitted with a message that follows the same canonical
+ * template so it is machine-parseable (see `DEPRECATION_MESSAGE_RE`) and
+ * consistent for readers:
+ *
+ *     `Subject` is deprecated since X.Y.Z and will be removed in A.B.C. Use `Replacement` instead.
+ *
+ * where the removal version `A.B.C` is a concrete semantic version (e.g.
+ * `2.0.0`) — we commit to the release that removes it rather than saying "a
+ * future release" — and the second sentence is `No replacement.` when there is
+ * nothing to migrate to, stated explicitly and never omitted. Additional
+ * sentences may follow.
+ *
+ * Symbols (classes, functions, methods, properties) are marked with the
+ * `@deprecated` JSDoc tag, which TypeScript tooling and IDEs flag statically,
+ * and warn at runtime with `warnDeprecated`. Everything else — parameters,
+ * fields, module moves, behavior/value changes — warns with `warnDeprecated`.
+ *
+ * Porting notes: pipedog does not port deprecated upstream APIs, so the
+ * PEP 702 `deprecated` decorator re-export, `renamed_init_field` (a dataclass
+ * constructor rewriter for renamed fields) and the deprecated
+ * `warn_deprecated_read` are not ported.
+ */
+import { logger } from "./logger.js";
+/**
+ * The canonical deprecation message, for symbol and hand-written warnings
+ * alike. Kept consistent and parseable so the developer-facing message agrees
+ * with the docstring directive.
+ */
+export const DEPRECATION_MESSAGE_RE = /^`(?<subject>[^`]+)` is deprecated since (?<version>\d+\.\d+\.\d+) and will be removed in (?<removal>\d+\.\d+\.\d+)\. (?:Use (?<replacement>.+) instead\.|No replacement\.)/;
+/**
+ * Call sites already warned about by `warnDeprecated`, identified by message
+ * and source location (`message\u0000location`).
+ *
+ * The record lasts for the life of the process, so a test asserting on one of
+ * these warnings clears it first.
+ */
+export const _warnedSites = new Set();
+// The stack line naming the caller `stacklevel` frames up from warnDeprecated's caller.
+function callSite(stacklevel) {
+    const stack = new Error().stack;
+    if (!stack)
+        return "";
+    const lines = stack.split("\n").filter((line) => /^\s+at\s|@/.test(line));
+    // `lines` drops the message line: 0 is callSite, 1 warnDeprecated, 2 the caller.
+    return lines[1 + stacklevel]?.trim() ?? "";
+}
+/**
+ * Warn once per call site that something deprecated was used.
+ *
+ * Many of Pipecat's deprecations are detected inside Pipecat, as a pipeline
+ * runs, so the warning is always logged, and a per-site record keeps it to one
+ * warning per call site: a deprecated field read wherever its object travels,
+ * or a check on every frame, would otherwise repeat without bound.
+ *
+ * @param message The warning message, following `DEPRECATION_MESSAGE_RE`.
+ * @param stacklevel Counted from the caller: `1` names the line that calls this
+ *   function, `2` its caller.
+ */
+export function warnDeprecated(message, stacklevel = 1) {
+    const site = `${message}\u0000${callSite(stacklevel)}`;
+    if (_warnedSites.has(site)) {
+        return;
+    }
+    _warnedSites.add(site);
+    logger.warning(`DeprecationWarning: ${message}`);
+}
+//# sourceMappingURL=deprecation.js.map

package/dist/utils/env.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Environment variable helpers.
+ *
+ * This module provides small, centralized parsing helpers for environment variables.
+ */
+/**
+ * Read an environment variable (Python's `os.getenv`), or `undefined` when it
+ * is not set or the runtime has no process environment (e.g. Cloudflare
+ * Workers without `nodejs_compat`).
+ */
+export declare function getEnv(name: string): string | undefined;
+/** Raised when an environment variable value cannot be parsed. */
+export declare class InvalidEnvVarValueError extends Error {
+    name: string;
+    /** The environment variable's name. */
+    readonly envName: string;
+    readonly value: string;
+    readonly expected: string;
+    /** Initialize an InvalidEnvVarValueError. */
+    constructor(options: {
+        name: string;
+        value: string;
+        expected: string;
+    });
+}
+/**
+ * Interpret an environment variable as a boolean.
+ *
+ * - If the variable is **not set**, returns `defaultValue`.
+ * - If the variable is set to a recognized boolean string, returns the parsed value.
+ * - Otherwise, throws `InvalidEnvVarValueError`.
+ *
+ * Recognized values (case-insensitive, whitespace ignored):
+ * - Truthy: "1", "true", "yes", "y", "on"
+ * - Falsy:  "0", "false", "no", "n", "off", ""
+ */
+export declare function envTruthy(name: string, defaultValue?: boolean): boolean;
+//# sourceMappingURL=env.d.ts.map

package/dist/utils/env.js

@@ -0,0 +1,62 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/env.py
+/**
+ * Environment variable helpers.
+ *
+ * This module provides small, centralized parsing helpers for environment variables.
+ */
+/**
+ * Read an environment variable (Python's `os.getenv`), or `undefined` when it
+ * is not set or the runtime has no process environment (e.g. Cloudflare
+ * Workers without `nodejs_compat`).
+ */
+export function getEnv(name) {
+    const env = globalThis.process
+        ?.env;
+    return env?.[name];
+}
+/** Raised when an environment variable value cannot be parsed. */
+export class InvalidEnvVarValueError extends Error {
+    name = "InvalidEnvVarValueError";
+    /** The environment variable's name. */
+    envName;
+    value;
+    expected;
+    /** Initialize an InvalidEnvVarValueError. */
+    constructor(options) {
+        super(`Invalid value for env var '${options.name}': '${options.value}'. Expected ${options.expected}.`);
+        // `name` is taken by Error, so the variable's name is `envName`.
+        this.envName = options.name;
+        this.value = options.value;
+        this.expected = options.expected;
+    }
+}
+const TRUTHY = new Set(["1", "true", "yes", "y", "on"]);
+const FALSY = new Set(["0", "false", "no", "n", "off", ""]);
+/**
+ * Interpret an environment variable as a boolean.
+ *
+ * - If the variable is **not set**, returns `defaultValue`.
+ * - If the variable is set to a recognized boolean string, returns the parsed value.
+ * - Otherwise, throws `InvalidEnvVarValueError`.
+ *
+ * Recognized values (case-insensitive, whitespace ignored):
+ * - Truthy: "1", "true", "yes", "y", "on"
+ * - Falsy:  "0", "false", "no", "n", "off", ""
+ */
+export function envTruthy(name, defaultValue = false) {
+    const raw = getEnv(name);
+    if (raw === undefined) {
+        return defaultValue;
+    }
+    const val = raw.trim().toLowerCase();
+    if (TRUTHY.has(val))
+        return true;
+    if (FALSY.has(val))
+        return false;
+    throw new InvalidEnvVarValueError({ name, value: raw, expected: "true or false" });
+}
+//# sourceMappingURL=env.js.map

package/dist/utils/errors.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Why an operation failed, independent of the provider that failed it.
+ *
+ * - UNKNOWN: The cause could not be determined.
+ * - AUTHENTICATION: Credentials are missing or invalid.
+ * - AUTHORIZATION: Credentials are valid but lack access to the resource.
+ * - INVALID_REQUEST: The request itself is malformed or names something that
+ *   doesn't exist, such as an unknown model or voice.
+ * - RATE_LIMIT: Too many requests were sent in too short a window.
+ * - QUOTA: The account's credit or usage allowance is exhausted.
+ * - CONNECTIVITY: The service could not be reached.
+ * - SERVER: The provider reported an internal failure.
+ * - APPLICATION: The application failed, not the provider. Reported by a
+ *   service on behalf of code it invoked — a tool handler, say — or for
+ *   application-supplied content a provider rejected once the service
+ *   has repaired its context (e.g. removed the rejected file message).
+ *   Either way the failure says nothing about the service's own health.
+ */
+export declare class ErrorCategory {
+    static readonly UNKNOWN: ErrorCategory;
+    static readonly AUTHENTICATION: ErrorCategory;
+    static readonly AUTHORIZATION: ErrorCategory;
+    static readonly INVALID_REQUEST: ErrorCategory;
+    static readonly RATE_LIMIT: ErrorCategory;
+    static readonly QUOTA: ErrorCategory;
+    static readonly CONNECTIVITY: ErrorCategory;
+    static readonly SERVER: ErrorCategory;
+    static readonly APPLICATION: ErrorCategory;
+    readonly name: string;
+    readonly value: string;
+    private constructor();
+    /** All categories, in declaration order. */
+    static values(): readonly ErrorCategory[];
+    /** The category with the given value (`ErrorCategory("quota")`). */
+    static fromValue(value: string): ErrorCategory;
+    /**
+     * Whether the failure will keep recurring until something changes.
+     *
+     * A permanent failure gives the same result every time it is retried:
+     * the credentials stay rejected, the request stays malformed. Only new
+     * credentials or settings can clear it, so retrying is pointless.
+     */
+    get isPermanent(): boolean;
+    toString(): string;
+}
+/**
+ * Classify an HTTP status code.
+ *
+ * @param statusCode The HTTP status code reported by the provider.
+ * @returns The matching category, or `ErrorCategory.UNKNOWN` if the code carries
+ *   no provider-independent meaning.
+ */
+export declare function classifyHttpStatusCode(statusCode: number): ErrorCategory;
+/**
+ * Extract an HTTP status code from an exception, if it carries one.
+ *
+ * Recognizes the attribute shapes used by the HTTP and websocket libraries
+ * services build on: a `response` holding `status_code` / `statusCode` or
+ * `status` (e.g. a fetch `Response`), and those same attributes directly on
+ * the exception (provider SDKs).
+ *
+ * @param exception The exception to inspect.
+ * @returns The status code, or null if the exception doesn't carry one.
+ */
+export declare function extractHttpStatusCode(exception: unknown): number | null;
+/**
+ * Classify an exception by the HTTP status code it carries.
+ *
+ * @param exception The exception to classify.
+ * @returns The matching category, or `ErrorCategory.UNKNOWN` when the exception is
+ *   not recognized. Providers that throw SDK-specific exceptions carrying no
+ *   status code need their own classification.
+ */
+export declare function classifyHttpException(exception: unknown): ErrorCategory;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -0,0 +1,202 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/errors.py
+/**
+ * Error classification shared by services.
+ *
+ * Provides a provider-agnostic vocabulary for *why* an operation failed, so that
+ * callers can tell a transient failure (worth retrying) from a permanent one
+ * (retrying will never help).
+ */
+import { TimeoutError } from "@pipedog/asyncio";
+/**
+ * Why an operation failed, independent of the provider that failed it.
+ *
+ * - UNKNOWN: The cause could not be determined.
+ * - AUTHENTICATION: Credentials are missing or invalid.
+ * - AUTHORIZATION: Credentials are valid but lack access to the resource.
+ * - INVALID_REQUEST: The request itself is malformed or names something that
+ *   doesn't exist, such as an unknown model or voice.
+ * - RATE_LIMIT: Too many requests were sent in too short a window.
+ * - QUOTA: The account's credit or usage allowance is exhausted.
+ * - CONNECTIVITY: The service could not be reached.
+ * - SERVER: The provider reported an internal failure.
+ * - APPLICATION: The application failed, not the provider. Reported by a
+ *   service on behalf of code it invoked — a tool handler, say — or for
+ *   application-supplied content a provider rejected once the service
+ *   has repaired its context (e.g. removed the rejected file message).
+ *   Either way the failure says nothing about the service's own health.
+ */
+export class ErrorCategory {
+    static UNKNOWN = new ErrorCategory("UNKNOWN", "unknown");
+    static AUTHENTICATION = new ErrorCategory("AUTHENTICATION", "authentication");
+    static AUTHORIZATION = new ErrorCategory("AUTHORIZATION", "authorization");
+    static INVALID_REQUEST = new ErrorCategory("INVALID_REQUEST", "invalid_request");
+    static RATE_LIMIT = new ErrorCategory("RATE_LIMIT", "rate_limit");
+    static QUOTA = new ErrorCategory("QUOTA", "quota");
+    static CONNECTIVITY = new ErrorCategory("CONNECTIVITY", "connectivity");
+    static SERVER = new ErrorCategory("SERVER", "server");
+    static APPLICATION = new ErrorCategory("APPLICATION", "application");
+    name;
+    value;
+    constructor(name, value) {
+        this.name = name;
+        this.value = value;
+    }
+    /** All categories, in declaration order. */
+    static values() {
+        return [
+            ErrorCategory.UNKNOWN,
+            ErrorCategory.AUTHENTICATION,
+            ErrorCategory.AUTHORIZATION,
+            ErrorCategory.INVALID_REQUEST,
+            ErrorCategory.RATE_LIMIT,
+            ErrorCategory.QUOTA,
+            ErrorCategory.CONNECTIVITY,
+            ErrorCategory.SERVER,
+            ErrorCategory.APPLICATION,
+        ];
+    }
+    /** The category with the given value (`ErrorCategory("quota")`). */
+    static fromValue(value) {
+        const category = ErrorCategory.values().find((c) => c.value === value);
+        if (!category) {
+            throw new Error(`'${value}' is not a valid ErrorCategory`);
+        }
+        return category;
+    }
+    /**
+     * Whether the failure will keep recurring until something changes.
+     *
+     * A permanent failure gives the same result every time it is retried:
+     * the credentials stay rejected, the request stays malformed. Only new
+     * credentials or settings can clear it, so retrying is pointless.
+     */
+    get isPermanent() {
+        return PERMANENT_CATEGORIES.has(this);
+    }
+    toString() {
+        return `ErrorCategory.${this.name}`;
+    }
+}
+const PERMANENT_CATEGORIES = new Set([
+    ErrorCategory.AUTHENTICATION,
+    ErrorCategory.AUTHORIZATION,
+    ErrorCategory.INVALID_REQUEST,
+]);
+const HTTP_STATUS_CODE_CATEGORIES = new Map([
+    [400, ErrorCategory.INVALID_REQUEST],
+    [401, ErrorCategory.AUTHENTICATION],
+    [402, ErrorCategory.QUOTA],
+    [403, ErrorCategory.AUTHORIZATION],
+    [404, ErrorCategory.INVALID_REQUEST],
+    [422, ErrorCategory.INVALID_REQUEST],
+    [429, ErrorCategory.RATE_LIMIT],
+]);
+// Error codes JS runtimes attach to connection failures (Python's
+// ConnectionError subclasses and socket.gaierror).
+const CONNECTIVITY_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ECONNABORTED",
+    "EPIPE",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ETIMEDOUT",
+    "ConnectionRefused",
+    "ConnectionClosed",
+]);
+// Python matches ConnectionError, TimeoutError and socket.gaierror. JS has no
+// such hierarchy: match asyncio/DOM timeouts, network errors, the error codes
+// above, and fetch's "fetch failed" TypeError (also on its `cause`).
+function isConnectivityError(exception) {
+    if (exception instanceof TimeoutError)
+        return true;
+    if (typeof exception !== "object" || exception === null)
+        return false;
+    const e = exception;
+    if (e.name === "TimeoutError" || e.name === "NetworkError")
+        return true;
+    if (typeof e.code === "string" && CONNECTIVITY_ERROR_CODES.has(e.code))
+        return true;
+    if (exception instanceof TypeError && typeof e.message === "string") {
+        if (/fetch failed|network|connect/i.test(e.message))
+            return true;
+    }
+    if (e.cause !== undefined && e.cause !== exception)
+        return isConnectivityError(e.cause);
+    return false;
+}
+/**
+ * Classify an HTTP status code.
+ *
+ * @param statusCode The HTTP status code reported by the provider.
+ * @returns The matching category, or `ErrorCategory.UNKNOWN` if the code carries
+ *   no provider-independent meaning.
+ */
+export function classifyHttpStatusCode(statusCode) {
+    const category = HTTP_STATUS_CODE_CATEGORIES.get(statusCode);
+    if (category) {
+        return category;
+    }
+    if (statusCode >= 500 && statusCode < 600) {
+        return ErrorCategory.SERVER;
+    }
+    return ErrorCategory.UNKNOWN;
+}
+function getAttr(obj, name) {
+    if ((typeof obj !== "object" && typeof obj !== "function") || obj === null)
+        return undefined;
+    return obj[name];
+}
+/**
+ * Extract an HTTP status code from an exception, if it carries one.
+ *
+ * Recognizes the attribute shapes used by the HTTP and websocket libraries
+ * services build on: a `response` holding `status_code` / `statusCode` or
+ * `status` (e.g. a fetch `Response`), and those same attributes directly on
+ * the exception (provider SDKs).
+ *
+ * @param exception The exception to inspect.
+ * @returns The status code, or null if the exception doesn't carry one.
+ */
+export function extractHttpStatusCode(exception) {
+    const response = getAttr(exception, "response");
+    const candidates = [
+        getAttr(response, "status_code"),
+        getAttr(response, "statusCode"),
+        getAttr(response, "status"),
+        getAttr(exception, "status_code"),
+        getAttr(exception, "statusCode"),
+        getAttr(exception, "status"),
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "number" && Number.isInteger(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Classify an exception by the HTTP status code it carries.
+ *
+ * @param exception The exception to classify.
+ * @returns The matching category, or `ErrorCategory.UNKNOWN` when the exception is
+ *   not recognized. Providers that throw SDK-specific exceptions carrying no
+ *   status code need their own classification.
+ */
+export function classifyHttpException(exception) {
+    const statusCode = extractHttpStatusCode(exception);
+    if (statusCode !== null) {
+        return classifyHttpStatusCode(statusCode);
+    }
+    if (isConnectivityError(exception)) {
+        return ErrorCategory.CONNECTIVITY;
+    }
+    return ErrorCategory.UNKNOWN;
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/file_resolver.d.ts

@@ -0,0 +1,126 @@
+import { type FileStorage } from "./file_storage.ts";
+import { IPNetwork, UrlReachability } from "./security/ssrf.ts";
+/** Raised when a file URL in the LLM context cannot be resolved to bytes. */
+export declare class FileResolverError extends Error {
+    name: string;
+}
+export interface FileResolverOptions {
+    /**
+     * Storage backend used to resolve URLs it minted (e.g. `pipecat:<id>` from
+     * the development runner's upload endpoints — pass `runnerArgs.fileStorage`
+     * there). Without it, only `data:` and `http(s)` URLs can be resolved.
+     */
+    fileStorage?: FileStorage | null;
+    /**
+     * CIDR ranges (e.g. `["10.0.0.0/8"]`) this server is trusted to fetch from,
+     * in addition to the public internet. An `http(s)` URL that resolves outside
+     * both is refused. Defaults to the `PIPECAT_ALLOWED_FILE_URL_NETWORKS` env
+     * var (comma-separated).
+     */
+    allowedUrlNetworks?: string[] | null;
+    /** Maximum size of a fetched file. */
+    maxFetchBytes?: number;
+    /** Total timeout for an `http(s)` fetch, in seconds. */
+    fetchTimeoutSecs?: number;
+}
+/**
+ * Fetches and caches the bytes behind file URLs the LLM provider can't fetch itself.
+ *
+ * Handles three kinds of URL:
+ *
+ * - `data:` URLs are decoded directly.
+ * - `http(s)` URLs are fetched by this server, but only when the resolved
+ *   address is publicly routable or falls within `allowedUrlNetworks` —
+ *   a client-supplied URL must not be able to point this server at arbitrary
+ *   private address space (SSRF). Redirects are refused rather than followed.
+ * - Any other scheme is delegated to `fileStorage`, which resolves the
+ *   URLs it minted (`pipecat:<id>` for `LocalFileStorage`; a custom backend
+ *   resolves whatever `save()` returned, e.g. `gs://` with the deployment's
+ *   own credentials).
+ *
+ * Each URL is fetched once and served from the cache afterwards: a URL is
+ * assumed to identify one immutable piece of content, the same assumption
+ * the rest of the web's caches make. Content that changes should live at a
+ * new URL (uploads through the development runner mint a fresh URL per
+ * upload; a cache-busting query string works for external URLs), or use
+ * `forget` when the application knows a URL's content changed. Note the flip
+ * side for URLs a provider consumes directly: the provider fetches those
+ * itself, on its own schedule, so their freshness is out of this resolver's
+ * hands entirely.
+ *
+ * A stored file whose backend sets `deleteAfterLoad` is deleted only after
+ * its bytes are cached, so the cache entry becomes the surviving copy — which
+ * is why LLM services that may consume the same files (e.g. services switched
+ * between mid-session) should share one resolver instance rather than each
+ * constructing their own. Scope a resolver to one session: an instance shared
+ * across sessions would hold every session's files in memory and stretch the
+ * one-fetch-per-URL assumption across all of them.
+ *
+ * Subclass and override `fetch` to support additional schemes or
+ * credentialed fetches beyond what the storage backend provides.
+ */
+export declare class FileResolver {
+    protected _fileStorage: FileStorage | null;
+    protected _allowedUrlNetworks: IPNetwork[];
+    protected _maxFetchBytes: number;
+    protected _fetchTimeoutSecs: number;
+    protected _bytesCache: Map<string, Uint8Array<ArrayBufferLike>>;
+    protected _dataUrlCache: Map<string, string>;
+    protected _reachabilityCache: Map<string, UrlReachability>;
+    constructor(options?: FileResolverOptions);
+    /** The storage backend used to resolve URLs it minted, if any. */
+    get fileStorage(): FileStorage | null;
+    /** Return the cached bytes for `url`, or null if it hasn't been fetched. */
+    cachedBytes(url: string): Uint8Array | null;
+    /**
+     * Return the cached `data:` form for `url`, or null if not prepared.
+     *
+     * A `data:` URL is its own data-URL form.
+     */
+    cachedDataUrl(url: string): string | null;
+    /** Return the cached reachability verdict for `url`, or null if unclassified. */
+    cachedReachability(url: string): UrlReachability | null;
+    /**
+     * Drop everything cached for `url`, forcing a re-fetch on next use.
+     *
+     * For applications that know a URL's content has changed. A forgotten
+     * `deleteAfterLoad` upload can't be re-fetched — its stored copy was
+     * deleted when first cached — so forgetting one makes it unresolvable.
+     *
+     * @param url The URL whose cached content and reachability to drop.
+     */
+    forget(url: string): void;
+    /**
+     * Classify who can reach an `http(s)` URL, honoring `allowedUrlNetworks`.
+     *
+     * Classified once per URL; later calls return the cached verdict.
+     */
+    classify(url: string): Promise<UrlReachability>;
+    /**
+     * Return the bytes behind `url`, fetching and caching them on first use.
+     *
+     * @param url A `data:` URL, an `http(s)` URL, or a URL minted by the
+     *   configured storage backend. A storage-resolved file is deleted after a
+     *   successful load when the backend sets `deleteAfterLoad` — the bytes are
+     *   cached first, so the cache entry becomes the surviving copy.
+     * @throws FileResolverError If the URL is refused by the reachability
+     *   policy, exceeds the size limit, fails to download, or has a scheme
+     *   nothing is configured to resolve.
+     */
+    fetch(url: string): Promise<Uint8Array>;
+    /**
+     * Return the `data:` form of `url`'s bytes, encoding and caching it on first use.
+     *
+     * For adapters whose provider consumes base64 rather than raw bytes, so
+     * the encode happens once rather than on every context conversion.
+     *
+     * @param url A URL whose bytes are cached or fetchable — see `fetch`.
+     * @param mimeType The file's MIME type, used in the data URL.
+     * @throws FileResolverError If the bytes can't be fetched.
+     */
+    ensureDataUrl(url: string, mimeType: string): Promise<string>;
+    protected _fetchUncached(url: string): Promise<Uint8Array>;
+    protected static _decodeDataUrl(url: string): Uint8Array;
+    protected _fetchHttp(url: string): Promise<Uint8Array>;
+}
+//# sourceMappingURL=file_resolver.d.ts.map