export { C as ConductorConfig, a as ConductorLane, b as ConductorStats, F as FrameFn, S as SubscribeOptions, c as SubscriberPriority, d as SubscriberStat, g as getConductor } from './conductor-CjhZukuO.cjs';
export { A as AdaptiveState, B as BudgetState, a as BudgetTier, D as DeviceSignals, M as MagneticElement, b as MagneticOptions, P as POINTER_INTENT_SENSITIVITY, c as PointerIntent, d as PointerIntentOptions, e as PointerIntentSensitivity, f as PointerIntentTuning, g as PointerSensor, h as PressureSource, i as PressureState, Q as QualityCause, R as RectLike, j as RendererHealthState, S as ScrollSensor, k as ScrubDriver, l as ScrubMapping, m as SensorBus, n as SensorState, V as VIDEO_SCRUBBER_DEFAULTS, o as VideoScrubber, p as VideoScrubberOptions, q as ViewportSensor, r as clamp01, s as damp, t as fuse, u as getAdaptiveQuality, v as getAnimationBudget, w as getFramePressure, x as getRendererHealth, y as getSensorBus, z as rayRectIntersect, C as scrollProgress } from './VideoScrubber-BbjCv9Nc.cjs';

/**
 * The part of `GPUDevice` this needs.
 *
 * Structural on purpose. `@webgpu/types` is not a dependency here and will not
 * become one: a real `GPUDevice` satisfies this shape, so a project that has
 * the types passes its device straight in, and a project that does not still
 * compiles. Same reasoning as the `CreatedState` shape in the R3F adapter.
 */
interface GPUDeviceLike {
    /**
     * Resolves when the device is lost. It resolves rather than rejects, which
     * is the detail most code gets wrong: a `.catch` here never fires.
     */
    lost: Promise<{
        reason?: string;
    } | undefined>;
}
/** Stop watching. Safe to call more than once. */
type StopWatchingDevice = () => void;
/**
 * Report a WebGPU device's health to the runtime.
 *
 * WebGL announces a dead context with a `webglcontextlost` event. WebGPU
 * announces a dead device by resolving `device.lost`, a promise handed to you
 * at creation. Different shape, same failure: the canvas stops producing
 * frames, nothing throws, and the console stays clean.
 *
 * ```ts
 * const device = await adapter.requestDevice();
 * const stop = watchGPUDevice(device);
 * // ...later, on teardown
 * stop();
 * ```
 *
 * What the runtime does with it is unchanged. A loss bumps `generation`, a
 * scene gate hands that to a `key`, and React builds the tree again against a
 * device you request fresh. The recovery path a WebGL scene already uses works
 * here without modification, because the counter never cared which API died.
 *
 * ## Why `destroyed` is ignored
 *
 * `GPUDeviceLostInfo.reason` is `"destroyed"` when the page called
 * `device.destroy()` itself, and unknown when the device actually failed. Only
 * the second is a failure worth rebuilding for.
 *
 * Treating a deliberate teardown as a loss is not hypothetical. The WebGL side
 * shipped exactly that bug: dropping a context on unmount reported a loss
 * *after* its replacement had already reported healthy, which bumped the
 * generation again and remounted everything, which unmounted more contexts.
 * One page reached generation 18 in a second with nobody touching it. A device
 * you destroyed on purpose is not a device that needs replacing.
 *
 * ## Cancellation
 *
 * A promise cannot be un-awaited, so `stop()` sets a flag the handler checks
 * rather than detaching anything. Call it in the same cleanup that destroys the
 * device, and a teardown ordering that resolves `lost` afterwards stays quiet.
 */
declare function watchGPUDevice(device: GPUDeviceLike): StopWatchingDevice;

/**
 * @vectorvesper/motion — core entry (".")
 *
 * Zero runtime dependencies. Framework-agnostic: usable from vanilla JS, Vue,
 * Svelte, or any renderer. React adapters live in "@vectorvesper/motion/react".
 *
 * ## What this entry exports
 *
 * The whole public core API. It is small on purpose: four singleton getters,
 * a few pure helpers, and the types you need to use them.
 *
 * The three effect engines (PointerIntent, MagneticElement, VideoScrubber)
 * ARE exported as of 3.0. Prefer the React hooks, which handle setup and
 * teardown for you; reach for the classes when there is no React, which is the
 * case this entry has advertised support for since 1.0 while shipping no way to
 * act on it. SensorBus and BudgetPolicy stay internal because you get their
 * instances from a getter. Refresh-rate detection and the device-tier
 * heuristic are internal.
 *
 * This surface can still change while 2.0 is in progress. Once 2.0 ships,
 * removing anything from it is a breaking change. `scripts/check-api.mjs`
 * diffs the built output against api-surface.json so nothing moves by
 * accident.
 */
/**
 * The published package version. Support questions start with "which version?",
 * and until now there was no way for a consumer to answer that at runtime.
 *
 * Substituted at build time from package.json by tsup's `define`, so it cannot
 * drift from the actual version.
 *
 * It was added hoping it would also fix a structural problem — this file is
 * otherwise entirely `export … from`, which compiles to a root entry whose every
 * statement forwards to a hashed chunk, and Framer's resolver rejects that as
 * "not a valid npm package (f3)". **It did not fix it.** With splitting on, and
 * with "./react" now mirroring this surface, the constant is shared between both
 * entries, so tsup hoists it into the chunk and the root stays a pure barrel.
 *
 * The working fix is that "./react" re-exports everything here — see
 * entry.react.ts. Import from "@vectorvesper/motion/react" in Framer.
 */
declare const VERSION: string;

export { type GPUDeviceLike, type StopWatchingDevice, VERSION, watchGPUDevice };