@czap/core 0.1.0

package/src/scheduler.ts

@@ -0,0 +1,161 @@
+/**
+ * Scheduler -- clock abstraction decoupling animation from requestAnimationFrame.
+ *
+ * Four implementations:
+ *   - raf: browser real-time (default)
+ *   - noop: SSR-safe
+ *   - fixedStep: deterministic timestamps at target fps (video rendering)
+ *   - audioSync: ticks in lockstep with an AVBridge sample counter
+ *
+ * @module
+ */
+
+import type { AVBridge } from './av-bridge.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface SchedulerShape {
+  readonly _tag: 'FrameScheduler';
+  schedule(callback: (now: number) => void): number;
+  cancel(id: number): void;
+}
+
+interface FixedStepShape extends SchedulerShape {
+  step(): void;
+  readonly frame: number;
+}
+
+// ---------------------------------------------------------------------------
+// Implementations
+// ---------------------------------------------------------------------------
+
+/** Default: requestAnimationFrame. Used by Timeline/animate in browser. */
+function _raf(): SchedulerShape {
+  return {
+    _tag: 'FrameScheduler',
+    schedule: (cb) => requestAnimationFrame(cb),
+    cancel: (id) => cancelAnimationFrame(id),
+  };
+}
+
+/** SSR-safe: noop scheduler for server environments. */
+function _noop(): SchedulerShape {
+  return {
+    _tag: 'FrameScheduler',
+    schedule: () => 0,
+    cancel: () => {},
+  };
+}
+
+/** Fixed-step: deterministic timestamps at target fps. For video rendering.
+ *  Uses a class for V8 hidden-class optimization (stable inline caches). */
+class FixedStepSchedulerImpl implements FixedStepShape {
+  readonly _tag = 'FrameScheduler' as const;
+  _frame: number = 0;
+  _cb: ((now: number) => void) | null = null;
+  _dt: number;
+
+  constructor(fps: number) {
+    this._dt = 1000 / fps;
+  }
+
+  get frame() {
+    return this._frame;
+  }
+
+  schedule(cb: (now: number) => void) {
+    this._cb = cb;
+    return this._frame;
+  }
+
+  cancel() {
+    this._cb = null;
+  }
+
+  step() {
+    const cb = this._cb;
+    if (cb) {
+      this._cb = null;
+      cb(this._frame * this._dt);
+    }
+    this._frame++;
+  }
+}
+
+function _fixedStep(fps: number): FixedStepShape {
+  return new FixedStepSchedulerImpl(fps);
+}
+
+// ---------------------------------------------------------------------------
+// Audio-sync scheduler
+// ---------------------------------------------------------------------------
+
+interface AudioSyncShape extends SchedulerShape {
+  poll(): void;
+  readonly frame: number;
+  readonly bridge: AVBridge.Shape;
+}
+
+function _audioSync(bridge: AVBridge.Shape): AudioSyncShape {
+  let lastFrame = -1;
+  let pendingCallback: ((now: number) => void) | null = null;
+
+  return {
+    _tag: 'FrameScheduler',
+    bridge,
+
+    get frame() {
+      return bridge.getCurrentFrame();
+    },
+
+    schedule(cb) {
+      pendingCallback = cb;
+      return bridge.getCurrentFrame();
+    },
+
+    cancel() {
+      pendingCallback = null;
+    },
+
+    poll() {
+      const currentFrame = bridge.getCurrentFrame();
+      if (currentFrame !== lastFrame) {
+        lastFrame = currentFrame;
+        const cb = pendingCallback;
+        if (cb) {
+          pendingCallback = null;
+          const timestampMs = bridge.sampleToTime(bridge.getCurrentSample()) * 1000;
+          cb(timestampMs);
+        }
+      }
+    },
+  };
+}
+
+/**
+ * Scheduler — clock abstraction that decouples animation driver from real time.
+ * Pick the impl that matches the runtime: `raf` in browser, `noop` on the
+ * server, `fixedStep` for deterministic video render, `audioSync` to drive UI
+ * in lockstep with an {@link AVBridge}.
+ */
+export const Scheduler = {
+  /** `requestAnimationFrame`-backed scheduler for browser real-time work. */
+  raf: _raf,
+  /** No-op scheduler for SSR / environments without rAF. */
+  noop: _noop,
+  /** Fixed-step scheduler at the given fps — deterministic timestamps for offline rendering. */
+  fixedStep: _fixedStep,
+  /** Scheduler that polls an {@link AVBridge} and fires callbacks when the sample frame advances. */
+  audioSync: _audioSync,
+};
+
+export declare namespace Scheduler {
+  /** Common structural shape every scheduler variant satisfies. */
+  export type Shape = SchedulerShape;
+  /** Fixed-step scheduler with manual `step()` advancement. */
+  export type FixedStep = FixedStepShape;
+  /** Audio-synchronized scheduler bound to an {@link AVBridge}. */
+  export type AudioSync = AudioSyncShape;
+}

package/src/ship-capsule.ts

@@ -0,0 +1,191 @@
+/**
+ * ShipCapsule — release-artifact receipt (ADR-0011).
+ *
+ * Same canonical-CBOR + ContentAddress kernel as runtime primitives, applied
+ * to a published-package tarball. `id` is the fnv1a label over the
+ * canonical bytes of every field except `id` and `integrity`; `integrity`
+ * pairs that label with a sha256 digest over the same bytes.
+ *
+ * @module
+ */
+
+import { Effect } from 'effect';
+import { decode as cborDecode } from 'cborg';
+import type { AddressedDigest, ContentAddress, HLC } from './brands.js';
+import { CanonicalCbor } from './cbor.js';
+import { AddressedDigest as AddressedDigestNs } from './addressed-digest.js';
+
+interface ShipCapsuleBuildEnv {
+  readonly node_version: string;
+  readonly pnpm_version: string;
+  readonly os: 'linux' | 'darwin' | 'win32';
+  readonly arch: 'x64' | 'arm64';
+}
+
+interface ShipCapsuleShape {
+  readonly _kind: 'shipCapsule';
+  readonly schema_version: 1;
+  readonly id: ContentAddress;
+  readonly integrity: AddressedDigest;
+  readonly package_name: string;
+  readonly package_version: string;
+  readonly source_commit: string;
+  readonly source_dirty: boolean;
+  readonly lockfile_address: AddressedDigest;
+  readonly workspace_manifest_address: AddressedDigest;
+  readonly tarball_manifest_address: AddressedDigest;
+  readonly build_env: ShipCapsuleBuildEnv;
+  readonly package_manager: 'pnpm';
+  readonly package_manager_version: string;
+  readonly publish_dry_run_address: AddressedDigest;
+  readonly lifecycle_scripts_observed: readonly string[];
+  readonly generated_at: HLC;
+  readonly previous_ship_capsule: ContentAddress | null;
+}
+
+type ShipCapsuleInput = Omit<ShipCapsuleShape, 'id' | 'integrity'>;
+
+type ShipCapsuleDecodeError = 'non_canonical' | 'malformed_cbor' | 'invalid_shape';
+
+const REQUIRED_KEYS: readonly (keyof ShipCapsuleShape)[] = [
+  '_kind',
+  'schema_version',
+  'id',
+  'integrity',
+  'package_name',
+  'package_version',
+  'source_commit',
+  'source_dirty',
+  'lockfile_address',
+  'workspace_manifest_address',
+  'tarball_manifest_address',
+  'build_env',
+  'package_manager',
+  'package_manager_version',
+  'publish_dry_run_address',
+  'lifecycle_scripts_observed',
+  'generated_at',
+  'previous_ship_capsule',
+];
+
+const encodeIdentityBearing = (capsule: ShipCapsuleInput): Uint8Array =>
+  CanonicalCbor.encode({
+    _kind: capsule._kind,
+    schema_version: capsule.schema_version,
+    package_name: capsule.package_name,
+    package_version: capsule.package_version,
+    source_commit: capsule.source_commit,
+    source_dirty: capsule.source_dirty,
+    lockfile_address: capsule.lockfile_address,
+    workspace_manifest_address: capsule.workspace_manifest_address,
+    tarball_manifest_address: capsule.tarball_manifest_address,
+    build_env: capsule.build_env,
+    package_manager: capsule.package_manager,
+    package_manager_version: capsule.package_manager_version,
+    publish_dry_run_address: capsule.publish_dry_run_address,
+    lifecycle_scripts_observed: capsule.lifecycle_scripts_observed,
+    generated_at: capsule.generated_at,
+    previous_ship_capsule: capsule.previous_ship_capsule,
+  });
+
+const computeId = (
+  capsuleWithoutIdentity: ShipCapsuleInput,
+): Effect.Effect<AddressedDigest, Error> => AddressedDigestNs.of(encodeIdentityBearing(capsuleWithoutIdentity));
+
+const make = (input: ShipCapsuleInput): Effect.Effect<ShipCapsuleShape, Error> =>
+  Effect.gen(function* () {
+    const digest = yield* computeId(input);
+    return {
+      _kind: input._kind,
+      schema_version: input.schema_version,
+      id: digest.display_id,
+      integrity: digest,
+      package_name: input.package_name,
+      package_version: input.package_version,
+      source_commit: input.source_commit,
+      source_dirty: input.source_dirty,
+      lockfile_address: input.lockfile_address,
+      workspace_manifest_address: input.workspace_manifest_address,
+      tarball_manifest_address: input.tarball_manifest_address,
+      build_env: input.build_env,
+      package_manager: input.package_manager,
+      package_manager_version: input.package_manager_version,
+      publish_dry_run_address: input.publish_dry_run_address,
+      lifecycle_scripts_observed: input.lifecycle_scripts_observed,
+      generated_at: input.generated_at,
+      previous_ship_capsule: input.previous_ship_capsule,
+    };
+  });
+
+const canonicalize = (capsule: ShipCapsuleShape): Uint8Array =>
+  CanonicalCbor.encode({
+    _kind: capsule._kind,
+    schema_version: capsule.schema_version,
+    id: capsule.id,
+    integrity: capsule.integrity,
+    package_name: capsule.package_name,
+    package_version: capsule.package_version,
+    source_commit: capsule.source_commit,
+    source_dirty: capsule.source_dirty,
+    lockfile_address: capsule.lockfile_address,
+    workspace_manifest_address: capsule.workspace_manifest_address,
+    tarball_manifest_address: capsule.tarball_manifest_address,
+    build_env: capsule.build_env,
+    package_manager: capsule.package_manager,
+    package_manager_version: capsule.package_manager_version,
+    publish_dry_run_address: capsule.publish_dry_run_address,
+    lifecycle_scripts_observed: capsule.lifecycle_scripts_observed,
+    generated_at: capsule.generated_at,
+    previous_ship_capsule: capsule.previous_ship_capsule,
+  });
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const validateShape = (value: unknown): value is ShipCapsuleShape => {
+  if (!isRecord(value)) return false;
+  for (const k of REQUIRED_KEYS) {
+    if (!(k in value)) return false;
+  }
+  if (value._kind !== 'shipCapsule') return false;
+  if (value.schema_version !== 1) return false;
+  if (!isRecord(value.integrity)) return false;
+  if (!isRecord(value.build_env)) return false;
+  if (!Array.isArray(value.lifecycle_scripts_observed)) return false;
+  if (!isRecord(value.generated_at)) return false;
+  return true;
+};
+
+const decode = (
+  bytes: Uint8Array,
+): Effect.Effect<ShipCapsuleShape, ShipCapsuleDecodeError> =>
+  Effect.gen(function* () {
+    let decoded: unknown;
+    try {
+      decoded = cborDecode(bytes);
+    } catch {
+      return yield* Effect.fail('malformed_cbor' as const);
+    }
+    if (!validateShape(decoded)) {
+      return yield* Effect.fail('invalid_shape' as const);
+    }
+    const reencoded = canonicalize(decoded);
+    if (reencoded.length !== bytes.length) {
+      return yield* Effect.fail('non_canonical' as const);
+    }
+    for (let i = 0; i < reencoded.length; i++) {
+      if (reencoded[i] !== bytes[i]) {
+        return yield* Effect.fail('non_canonical' as const);
+      }
+    }
+    return decoded;
+  });
+
+export const ShipCapsule = { make, canonicalize, decode, computeId };
+
+export declare namespace ShipCapsule {
+  export type Shape = ShipCapsuleShape;
+  export type Input = ShipCapsuleInput;
+  export type DecodeError = ShipCapsuleDecodeError;
+  export type BuildEnv = ShipCapsuleBuildEnv;
+}

package/src/signal.ts

@@ -0,0 +1,345 @@
+/**
+ * Signal -- live data feeds from the browser environment.
+ *
+ * (viewport, scroll, pointer, time, media queries, custom).
+ *
+ * @module
+ */
+
+import type { Stream, Scope } from 'effect';
+import { Effect, SubscriptionRef, Ref } from 'effect';
+import type { AVBridge } from './av-bridge.js';
+
+/** Tag of a {@link SignalSource} — the family of live data feed a signal binds to. */
+export type SignalSourceType = 'viewport' | 'time' | 'pointer' | 'scroll' | 'media' | 'custom' | 'audio';
+
+/**
+ * Configuration describing what a {@link Signal} reads from: viewport axis,
+ * time mode, pointer axis, scroll axis, media query, custom push source,
+ * or audio sample/normalized mode.
+ */
+export type SignalSource =
+  | { readonly type: 'viewport'; readonly axis: 'width' | 'height' }
+  | { readonly type: 'time'; readonly mode: 'elapsed' | 'absolute' | 'scheduled' }
+  | { readonly type: 'pointer'; readonly axis: 'x' | 'y' | 'pressure' }
+  | { readonly type: 'scroll'; readonly axis: 'x' | 'y' | 'progress' }
+  | { readonly type: 'media'; readonly query: string }
+  | { readonly type: 'custom'; readonly id: string }
+  | { readonly type: 'audio'; readonly mode: 'sample' | 'normalized' };
+
+interface SignalShape<T> {
+  readonly source: SignalSource;
+  readonly current: Effect.Effect<T>;
+  readonly changes: Stream.Stream<T>;
+}
+
+interface ControllableSignalShape<T> extends SignalShape<T> {
+  seek(to: T): Effect.Effect<void>;
+  pause(): Effect.Effect<void>;
+  resume(): Effect.Effect<void>;
+}
+
+function initialValueForSource(source: SignalSource): number {
+  switch (source.type) {
+    case 'viewport':
+      return typeof globalThis.window !== 'undefined'
+        ? source.axis === 'width'
+          ? window.innerWidth
+          : window.innerHeight
+        : 0;
+    case 'scroll':
+      if (typeof globalThis.window === 'undefined') return 0;
+      if (source.axis === 'x') return window.scrollX;
+      if (source.axis === 'y') return window.scrollY;
+      {
+        const max = document.documentElement.scrollHeight - window.innerHeight;
+        return max > 0 ? window.scrollY / max : 0;
+      }
+    case 'pointer':
+      return 0;
+    case 'time':
+      return source.mode === 'absolute' ? Date.now() : 0;
+    case 'media':
+      return typeof globalThis.window !== 'undefined' && window.matchMedia(source.query).matches ? 1 : 0;
+    case 'custom':
+      return 0;
+    case 'audio':
+      return 0;
+  }
+}
+
+/**
+ * Create a reactive signal from a browser environment source.
+ *
+ * Returns a scoped Effect that sets up event listeners (resize, scroll,
+ * pointermove, etc.) and cleans them up when the scope closes. The signal
+ * exposes `.current` (latest value) and `.changes` (stream of updates).
+ *
+ * @example
+ * ```ts
+ * import { Effect, Scope } from 'effect';
+ * import { Signal } from '@czap/core';
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const sig = yield* Signal.make({ type: 'viewport', axis: 'width' });
+ *   const width = yield* sig.current;
+ *   // width === current window.innerWidth
+ * }));
+ * ```
+ */
+function _make(source: SignalSource): Effect.Effect<SignalShape<number>, never, Scope.Scope> {
+  return Effect.gen(function* () {
+    const initial = initialValueForSource(source);
+    const ref = yield* SubscriptionRef.make(initial);
+
+    const setupListener = Effect.gen(function* () {
+      switch (source.type) {
+        case 'viewport': {
+          if (typeof globalThis.window === 'undefined') return;
+          const handler = () => {
+            const val = source.axis === 'width' ? window.innerWidth : window.innerHeight;
+            Effect.runSync(SubscriptionRef.set(ref, val));
+          };
+          yield* Effect.acquireRelease(
+            Effect.sync(() => {
+              window.addEventListener('resize', handler);
+            }),
+            () =>
+              Effect.sync(() => {
+                window.removeEventListener('resize', handler);
+              }),
+          );
+          break;
+        }
+        case 'scroll': {
+          if (typeof globalThis.window === 'undefined') return;
+          const handler = () => {
+            let val: number;
+            if (source.axis === 'x') val = window.scrollX;
+            else if (source.axis === 'y') val = window.scrollY;
+            else {
+              const max = document.documentElement.scrollHeight - window.innerHeight;
+              val = max > 0 ? window.scrollY / max : 0;
+            }
+            Effect.runSync(SubscriptionRef.set(ref, val));
+          };
+          yield* Effect.acquireRelease(
+            Effect.sync(() => {
+              window.addEventListener('scroll', handler, { passive: true });
+            }),
+            () =>
+              Effect.sync(() => {
+                window.removeEventListener('scroll', handler);
+              }),
+          );
+          break;
+        }
+        case 'pointer': {
+          if (typeof globalThis.window === 'undefined') return;
+          const handler = (e: PointerEvent) => {
+            const val = source.axis === 'x' ? e.clientX : source.axis === 'y' ? e.clientY : e.pressure;
+            Effect.runSync(SubscriptionRef.set(ref, val));
+          };
+          yield* Effect.acquireRelease(
+            Effect.sync(() => {
+              window.addEventListener('pointermove', handler);
+            }),
+            () =>
+              Effect.sync(() => {
+                window.removeEventListener('pointermove', handler);
+              }),
+          );
+          break;
+        }
+        case 'time': {
+          if (source.mode === 'elapsed') {
+            if (typeof requestAnimationFrame === 'undefined') return;
+            const start = Date.now();
+            const id = { current: 0 };
+            const tick = () => {
+              Effect.runSync(SubscriptionRef.set(ref, Date.now() - start));
+              id.current = requestAnimationFrame(tick);
+            };
+            id.current = requestAnimationFrame(tick);
+            yield* Effect.addFinalizer(() => Effect.sync(() => cancelAnimationFrame(id.current)));
+          } else if (source.mode === 'absolute') {
+            const id = setInterval(() => {
+              Effect.runSync(SubscriptionRef.set(ref, Date.now()));
+            }, 1000);
+            yield* Effect.addFinalizer(() => Effect.sync(() => clearInterval(id)));
+          } else {
+            // Scheduled mode: no automatic ticking.
+            // External code drives this signal via SubscriptionRef.set(ref, value).
+            // The ref is already created -- caller controls it via ControllableSignal.
+          }
+          break;
+        }
+        case 'media': {
+          if (typeof globalThis.window === 'undefined') return;
+          const mql = window.matchMedia(source.query);
+          const handler = (e: MediaQueryListEvent) => {
+            Effect.runSync(SubscriptionRef.set(ref, e.matches ? 1 : 0));
+          };
+          yield* Effect.acquireRelease(
+            Effect.sync(() => {
+              mql.addEventListener('change', handler);
+            }),
+            () =>
+              Effect.sync(() => {
+                mql.removeEventListener('change', handler);
+              }),
+          );
+          break;
+        }
+        case 'custom':
+          // Custom signals are driven externally via Signal.custom() push API.
+          // No browser listener needed — the caller pushes values directly.
+          break;
+        case 'audio':
+          // Audio signals are driven externally via Signal.audio() / AVBridge.
+          // No browser listener needed — audio analysis pushes values on its own cadence.
+          break;
+      }
+    });
+
+    yield* Effect.forkScoped(setupListener);
+
+    return {
+      source,
+      current: SubscriptionRef.get(ref),
+      changes: SubscriptionRef.changes(ref),
+    };
+  });
+}
+
+/**
+ * Create a controllable time signal for video rendering / scrubbing.
+ *
+ * External code drives the signal value via seek(); no automatic ticking.
+ * Supports pause/resume to temporarily ignore seek updates.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Signal } from '@czap/core';
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const ctrl = yield* Signal.controllable();
+ *   yield* ctrl.seek(1500);
+ *   const t = yield* ctrl.current;
+ *   // t === 1500
+ *   yield* ctrl.pause();
+ *   yield* ctrl.seek(2000); // ignored while paused
+ * }));
+ * ```
+ */
+function _controllable(): Effect.Effect<ControllableSignalShape<number>, never, Scope.Scope> {
+  return Effect.gen(function* () {
+    const ref = yield* SubscriptionRef.make(0);
+    const pausedRef = yield* Ref.make(false);
+
+    return {
+      source: { type: 'time' as const, mode: 'scheduled' as const },
+      current: SubscriptionRef.get(ref),
+      changes: SubscriptionRef.changes(ref),
+      seek: (to: number) =>
+        Effect.gen(function* () {
+          const paused = yield* Ref.get(pausedRef);
+          if (!paused) {
+            yield* SubscriptionRef.set(ref, to);
+          }
+        }),
+      pause: () => Ref.set(pausedRef, true),
+      resume: () => Ref.set(pausedRef, false),
+    };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Audio signal
+// ---------------------------------------------------------------------------
+
+interface AudioSignalShape extends SignalShape<number> {
+  poll(): Effect.Effect<number>;
+}
+
+/**
+ * Create an audio signal backed by an AVBridge.
+ *
+ * In 'sample' mode, returns the raw sample index. In 'normalized' mode,
+ * returns a 0..1 progress value based on totalDurationSec. Call `.poll()`
+ * to read the latest sample from the bridge and update the signal.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Signal } from '@czap/core';
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const audioSig = yield* Signal.audio(bridge, 'normalized', 120);
+ *   const progress = yield* audioSig.poll();
+ *   // progress is a number between 0 and 1
+ * }));
+ * ```
+ */
+function _audio(
+  bridge: AVBridge.Shape,
+  mode: 'sample' | 'normalized' = 'sample',
+  totalDurationSec?: number,
+): Effect.Effect<AudioSignalShape, never, Scope.Scope> {
+  return Effect.gen(function* () {
+    const ref = yield* SubscriptionRef.make(0);
+
+    const poll = () =>
+      Effect.gen(function* () {
+        const sample = bridge.getCurrentSample();
+        let value: number;
+        if (mode === 'normalized' && totalDurationSec !== undefined && totalDurationSec > 0) {
+          const totalSamples = totalDurationSec * bridge.sampleRate;
+          value = Math.min(sample / totalSamples, 1);
+        } else {
+          value = sample;
+        }
+        yield* SubscriptionRef.set(ref, value);
+        return value;
+      });
+
+    return {
+      source: { type: 'audio' as const, mode } as const,
+      current: SubscriptionRef.get(ref),
+      changes: SubscriptionRef.changes(ref),
+      poll: () => poll(),
+    };
+  });
+}
+
+/**
+ * Signal namespace -- live data feeds from the browser environment.
+ *
+ * Create reactive signals from viewport, scroll, pointer, time, media query,
+ * audio, or custom sources. Each signal provides `.current` and `.changes`
+ * backed by Effect's SubscriptionRef. Scoped for automatic listener cleanup.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Signal } from '@czap/core';
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const viewport = yield* Signal.make({ type: 'viewport', axis: 'width' });
+ *   const width = yield* viewport.current;
+ *   const ctrl = yield* Signal.controllable();
+ *   yield* ctrl.seek(500);
+ * }));
+ * ```
+ */
+export const Signal = { make: _make, controllable: _controllable, audio: _audio };
+
+export declare namespace Signal {
+  /** Structural shape of a passive {@link Signal}: `source` + `current` + `changes`. */
+  export type Shape<T> = SignalShape<T>;
+  /** Structural shape of a seekable, pausable signal — e.g. driven by Remotion or a scrub UI. */
+  export type Controllable<T> = ControllableSignalShape<T>;
+  /** Structural shape of an audio-sourced signal backed by an {@link AVBridge}. */
+  export type Audio = AudioSignalShape;
+}