@@ -761,6 +761,8 @@
       // boundary, while htmlBundler keeps parallel module/classic-script paths.
       "packages/inspector/tests/browser.ts",
       "packages/inspector/tests/film.ts",
+      "packages/inspector/tests/timeline.ts",
+      "packages/inspector/tests/timelineCompositions.ts",
       "packages/core/src/compiler/htmlBundler.ts",
     ],
   },
@@ -1030,6 +1032,12 @@
       "packages/inspector/src/server.ts",
       "packages/core/src/runtime/inspection.ts",
       "packages/inspector/tests/film.ts",
+      "packages/inspector/src/mapInspection.ts",
+      "packages/inspector/src/live.ts",
+      "packages/inspector/src/elementMap.js",
+      "packages/inspector/src/sourceDependencies.ts",
+      "packages/core/src/runtime/timelineInspection.ts",
+      "packages/cli/src/commands/timeline.ts",
     ],
   },
 }
@@ -380,6 +380,11 @@ jobs:
           node-version: 22
       - uses: ./.github/actions/prepare-ffmpeg-bin
       - run: bash scripts/ci/install-workspace-dependencies.sh
+      - name: Build generated inspector inputs
+        run: |
+          bun run --filter '@hyperframes/{parsers,lint}' build
+          bun run build:hyperframes-runtime
+          bun run --filter @hyperframes/inspector build
       - name: Run fallow audit
         id: audit
         # `bun install` above made `bunx fallow` resolve from node_modules, so
 
@@ -91,6 +91,29 @@ export default defineCommand({
   meta: { name: "timeline", description: "Print and edit the project's tracks and clips" },
   args: {
     dir: { type: "positional", description: "Project directory", required: false },
+    component: {
+      type: "string",
+      description:
+        "Unique component selector, or JSON target {selector|hfId|ref}; runtime inspection",
+    },
+    at: { type: "string", description: "Global second; requires the inspector service" },
+    range: {
+      type: "string",
+      description: "Global start,end (half-open); requires the inspector service",
+    },
+    boundary: {
+      type: "string",
+      description: "Global boundary second; requires the inspector service",
+    },
+    generation: {
+      type: "string",
+      description: "Inspector generation for a continued runtime query",
+    },
+    offset: {
+      type: "string",
+      description: "Group offset for a continued runtime query",
+    },
+
     json: { type: "boolean", description: "Output as JSON", default: false },
   },
   subCommands,
@@ -106,6 +129,42 @@ export default defineCommand({
     if (isTimelineSubcommand(args._[0], rawArgs)) return;
     resolveExtraPositionals({ args: cmd.args }, "timeline", args);
     const project = resolveProject(args.dir);
+    if ([args.component, args.at, args.range, args.boundary].some((v) => v !== undefined)) {
+      const url = process.env.HF_INSPECT_URL;
+      if (!url || !/^http:\/\/(127\.0\.0\.1|localhost):\d+$/.test(url))
+        throw new Error(
+          "Runtime timeline queries require HF_INSPECT_URL from the existing inspector service.",
+        );
+      const info = await fetch(`${url}/info`, { signal: AbortSignal.timeout(5000) }).then((r) =>
+        r.json(),
+      );
+      const { realpathSync } = await import("node:fs");
+      const { dirname } = await import("node:path");
+      if (realpathSync(info.project) !== realpathSync(dirname(project.indexPath)))
+        throw new Error("Inspector service belongs to another project");
+      const component = args.component?.trim().startsWith("{")
+        ? JSON.parse(args.component)
+        : args.component
+          ? { selector: args.component }
+          : undefined;
+      const response = await fetch(`${url}/timeline`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          component,
+          at: args.at === undefined ? undefined : Number(args.at),
+          range: args.range?.split(",").map(Number),
+          boundary: args.boundary === undefined ? undefined : Number(args.boundary),
+          generation: args.generation,
+          offset: args.offset === undefined ? undefined : Number(args.offset),
+        }),
+        signal: AbortSignal.timeout(60000),
+      });
+      const result = await response.json();
+      if (!response.ok) throw new Error(result.error ?? "Timeline query failed");
+      console.log(args.json ? JSON.stringify(result) : result.text);
+      return;
+    }
     ensureDOMParser();
     const timeline = await describeProject(project.indexPath);
     console.log(
 
@@ -831,20 +831,18 @@ function stripJsCommentsParserSafe(
 ): string {
   if (!source) return source;
   try {
-    const result = transformSync(source, { loader: "js", minify: false, legalComments: "none" });
+    const result = transformSync(source, {
+      loader: "js",
+      minify: false,
+      legalComments: "none",
+      ...(provenance
+        ? { sourcemap: "external" as const, sourcefile: "hf-authored-bundle.js" }
+        : {}),
+    });
     if (provenance) {
-      const mapped = transformSync(source, {
-        loader: "js",
-        minify: false,
-        legalComments: "none",
-        sourcemap: "external",
-        sourcefile: "hf-authored-bundle.js",
-      });
-      if (mapped.code.trim() === result.code.trim()) {
-        const sourceURL = `hf-inspect-${createHash("sha256").update(source).digest("hex")}.js`;
-        provenance({ input: source, output: result.code.trim(), sourceMap: mapped.map, sourceURL });
-        return `${result.code.trim()}\n//# sourceURL=${sourceURL}`;
-      }
+      const sourceURL = `hf-inspect-${createHash("sha256").update(source).digest("hex")}.js`;
+      provenance({ input: source, output: result.code.trim(), sourceMap: result.map, sourceURL });
+      return `${result.code.trim()}\n//# sourceURL=${sourceURL}`;
     }
     return result.code.trim();
   } catch {
 
@@ -1,3 +1,9 @@
+import {
+  inspectTimelineRuntime,
+  type TimelineRequest,
+  type TimedAnimation,
+  type TimelineRuntimeResult,
+} from "./timelineInspection";
 import type {
   ElementRef,
   RuntimeAnimation,
@@ -23,7 +29,12 @@ interface Gsap {
 }
 interface InspectorWindow extends Omit<Window, "__timelines" | "gsap"> {
   gsap?: Gsap;
-  __hfInspection?: { query: (q: RuntimeQuery) => RuntimeResponse; dispose: () => void };
+  __hfInspection?: {
+    query: (q: RuntimeQuery) => RuntimeResponse;
+    timeline: (q: TimelineRequest) => TimelineRuntimeResult;
+    dispose: () => void;
+  };
+  __timelines?: Record<string, TimedAnimation>;
 }
 const animation = (value: unknown): value is Animation =>
   !!value &&
@@ -191,16 +202,34 @@ export function installInspection(win: InspectorWindow, generation: string, limi
         } catch {
           return { ...base, status: "invalid-selector" };
         }
-        if (elements.length !== 1)
+        if (elements.length === 0)
           return {
             ...base,
-            status: elements.length ? "ambiguous" : "missing",
+            status: "missing",
             candidates: elements.slice(0, 20).map(describe),
             truncated: elements.length > 20,
           };
-        const targetElement = elements[0]!;
-        const descendants = q.descendants ? [...targetElement.querySelectorAll("*")] : [];
-        const scope = [targetElement, ...descendants.slice(0, 1000)];
+        const selected = new Set<Element>();
+        let truncated = false;
+        const add = (el: Element) => {
+          if (selected.has(el)) return;
+          if (selected.size >= 1001) {
+            truncated = true;
+            return;
+          }
+          selected.add(el);
+        };
+        for (const element of elements) {
+          add(element);
+          if (q.descendants) {
+            for (const child of element.querySelectorAll("*")) {
+              add(child);
+              if (truncated) break;
+            }
+          }
+          if (truncated) break;
+        }
+        const scope = [...selected];
         const animations = (gsap?.getTweensOf?.(scope) ?? []).map((tw): RuntimeAnimation => {
           const attachmentStacks: string[] = [];
           const visited = new Set<Animation>();
@@ -236,15 +265,48 @@ export function installInspection(win: InspectorWindow, generation: string, limi
         return {
           ...base,
           status: "found",
-          candidates: [describe(targetElement)],
+          candidates: elements.slice(0, 1001).map(describe),
           elements: scope.map(describe),
           animations,
           css,
-          truncated: descendants.length > 1000,
+          truncated,
         };
       });
       return { results, recorded: count, recordLimitReached: count >= limit, hooked: !!gsap };
     },
+    timeline(q: TimelineRequest): TimelineRuntimeResult {
+      let scope: Element = document.documentElement;
+      if (q.component) {
+        const found = api.query({ targets: [q.component], descendants: false, cssRules: [] })
+          .results[0];
+        if (!found) return { status: "missing", candidates: [], events: [], warnings: [] };
+        if (found.status !== "found")
+          return { status: found.status, candidates: found.candidates, events: [], warnings: [] };
+        const [only, ...others] = found.candidates;
+        if (!only || others.length > 0)
+          return { status: "ambiguous", candidates: found.candidates, events: [], warnings: [] };
+        const el = refs.get(only.ref)?.deref();
+        if (!el) return { status: "stale-ref", candidates: [], events: [], warnings: [] };
+        scope = el;
+      }
+      const registered = Object.values(win.__timelines ?? {});
+      const roots = registered.filter(
+        (root) =>
+          !registered.some(
+            (other) =>
+              other !== root && (other.getChildren?.(true, false, true) ?? []).includes(root),
+          ),
+      );
+      return inspectTimelineRuntime(
+        q,
+        roots,
+        scope,
+        describe,
+        (a) => records.get(a) ?? null,
+        reserved,
+        win.__timelines ?? {},
+      );
+    },
     dispose() {
       disposed = true;
       for (const restore of restorers.reverse()) restore();