@hyperframes/core 0.8.214 → 0.8.216

package/dist/audioRhythm.d.ts

@@ -49,3 +49,9 @@ export declare function bandFramesOf(signal: AudioSignal): BandFrames;
 export declare function rhythm(signal: AudioSignal): Rhythm;
 /** `rhythm`, yielding between short pieces of work. */
 export declare function rhythmSteps(signal: AudioSignal): Steps<Rhythm>;
+export interface BeatEvidence {
+    confidence: number;
+    lift: number;
+}
+/** Steady-beat confidence over six seconds around each time, and its onset's lift there, at any level. */
+export declare function localBeatEvidence(signal: AudioSignal, times: readonly number[], beatSeconds?: number): BeatEvidence[];

package/dist/audioRhythm.js

@@ -422,3 +422,27 @@ export function* rhythmSteps(signal) {
     entry.rhythm ??= yield* rhythmOf(entry.frames);
     return entry.rhythm;
 }
+const SPAN_SECONDS = 6;
+/** Steady-beat confidence over six seconds around each time, and its onset's lift there, at any level. */
+export function localBeatEvidence(signal, times, beatSeconds) {
+    const { broad, fps } = onsetCurves(bandFramesOf(signal));
+    const half = Math.round((SPAN_SECONDS / 2) * fps);
+    const whole = beatSeconds ?? medianInterval(times) ?? 0;
+    if (whole * fps < 2)
+        return times.map(() => ({ confidence: 0, lift: 0 }));
+    const local = smoothed(broad, whole * fps);
+    return times.map((t) => {
+        const centre = Math.round((t - ONSET_LAG_SECONDS) * fps);
+        const from = Math.max(0, centre - half);
+        const to = Math.min(broad.length, centre + half);
+        const near = times.filter((other) => Math.abs(other - t) * fps <= half);
+        const lag = Math.round((beatSeconds ?? medianInterval(near) ?? whole) * fps);
+        const ac = autocorrelation(broad.subarray(from, to), lag + 1);
+        const clarity = Math.max(ac[lag - 1] ?? 0, ac[lag] ?? 0, ac[lag + 1] ?? 0);
+        const span = local.subarray(from, to);
+        const mean = span.reduce((sum, v) => sum + v, 0) / (span.length || 1);
+        const peak = Math.max(...[-2, -1, 0, 1, 2].map((d) => local[centre + d] ?? 0));
+        const lift = mean > 0 ? peak / mean - 1 : 0;
+        return { confidence: beatConfidence(clarity, lift), lift };
+    });
+}

package/dist/colorGroups.d.ts

@@ -14,10 +14,12 @@ type GroupLookupRoot = Pick<Document, "getElementById"> | null | undefined;
  */
 export declare function colorGroupOf(el: Element): string | null;
 /**
- * The `<hf-color-group>` for an id, or null. Tag-checked so an unrelated
+ * The `<hf-color-group>` for an id, or null. Ids are unique only per
+ * composition file, so a member's own composition is searched first, as audio
+ * groups pair per composition; then the document. Tag-checked so an unrelated
  * element sharing the id is never read as a lane's grade.
  */
-export declare function resolveColorGroupElement(root: GroupLookupRoot, groupId: string): Element | null;
+export declare function resolveColorGroupElement(root: GroupLookupRoot, groupId: string, member?: Element): Element | null;
 /**
  * The grade that applies to `el`: its own `data-color-grading` when present,
  * else its group element's, else null. A group id with no element is ungrouped.

package/dist/colorGroups.js

@@ -22,10 +22,18 @@ export function colorGroupOf(el) {
     return el.getAttribute(HF_COLOR_GROUP_ATTR) || null;
 }
 /**
- * The `<hf-color-group>` for an id, or null. Tag-checked so an unrelated
+ * The `<hf-color-group>` for an id, or null. Ids are unique only per
+ * composition file, so a member's own composition is searched first, as audio
+ * groups pair per composition; then the document. Tag-checked so an unrelated
  * element sharing the id is never read as a lane's grade.
  */
-export function resolveColorGroupElement(root, groupId) {
+export function resolveColorGroupElement(root, groupId, member) {
+    const scope = typeof member?.closest === "function" ? member.closest("[data-composition-id]") : null;
+    const scoped = scope
+        ? Array.from(scope.getElementsByTagName(HF_COLOR_GROUP_TAG)).find((g) => g.id === groupId)
+        : undefined;
+    if (scoped)
+        return scoped;
     const el = root?.getElementById(groupId) ?? null;
     return el?.tagName.toLowerCase() === HF_COLOR_GROUP_TAG ? el : null;
 }
@@ -40,7 +48,7 @@ export function effectiveColorGrading(el, root) {
     const groupId = colorGroupOf(el);
     if (!groupId)
         return null;
-    return resolveColorGroupElement(root, groupId)?.getAttribute(HF_COLOR_GRADING_ATTR) ?? null;
+    return resolveColorGroupElement(root, groupId, el)?.getAttribute(HF_COLOR_GRADING_ATTR) ?? null;
 }
 /**
  * Make `<hf-color-group>` inert, once per document: an unknown custom element

package/dist/envProxy.d.ts

@@ -0,0 +1,4 @@
+/** Whether `fetch` follows the proxy variables (`NODE_USE_ENV_PROXY=1` or `--use-env-proxy`). */
+export declare function envProxyEnabled(env?: NodeJS.ProcessEnv, execArgv?: readonly string[]): boolean;
+/** Whether `fetch` reaches the network through `HTTPS_PROXY`, which then does the name resolution. */
+export declare function fetchGoesThroughEnvProxy(env?: NodeJS.ProcessEnv, execArgv?: readonly string[]): boolean;

package/dist/envProxy.js

@@ -0,0 +1,9 @@
+/** Whether `fetch` follows the proxy variables (`NODE_USE_ENV_PROXY=1` or `--use-env-proxy`). */
+export function envProxyEnabled(env = process.env, execArgv = process.execArgv) {
+    const flags = [...execArgv, ...(env["NODE_OPTIONS"]?.split(/\s+/u) ?? [])];
+    return env["NODE_USE_ENV_PROXY"] === "1" || flags.includes("--use-env-proxy");
+}
+/** Whether `fetch` reaches the network through `HTTPS_PROXY`, which then does the name resolution. */
+export function fetchGoesThroughEnvProxy(env = process.env, execArgv = process.execArgv) {
+    return (Boolean((env["HTTPS_PROXY"] ?? env["https_proxy"])?.trim()) && envProxyEnabled(env, execArgv));
+}