diff --git a/e2e-tests/fixtures/Plan.ts b/e2e-tests/fixtures/Plan.ts
index c1ed229295..bb24a82680 100644
--- a/e2e-tests/fixtures/Plan.ts
+++ b/e2e-tests/fixtures/Plan.ts
@@ -337,6 +337,7 @@ export class Plan {
   async goto(planId = this.plans.planId) {
     await this.page.goto(`/plans/${planId}`, { waitUntil: 'load' });
     await this.page.waitForURL(`/plans/${planId}`, { waitUntil: 'load' });
+    await this.planTitle.waitFor({ state: 'visible' });
     await this.waitForTimelineLoading();
   }
 
diff --git a/e2e-tests/tests/plan-external-source.test.ts b/e2e-tests/tests/plan-external-source.test.ts
index b988e9fb69..5aa482ad41 100644
--- a/e2e-tests/tests/plan-external-source.test.ts
+++ b/e2e-tests/tests/plan-external-source.test.ts
@@ -1,6 +1,7 @@
 import test, { expect } from '@playwright/test';
 import { ExternalSources } from '../fixtures/ExternalSources.js';
 import { PanelNames, Plan } from '../fixtures/Plan.js';
+import { anyCanvasHasContent } from '../utilities/canvas.js';
 import {
   cleanupApiResources,
   closeBrowserResources,
@@ -157,22 +158,7 @@ test.describe.serial('Plan External Sources', () => {
   });
 
   test('Zero-duration events are properly drawn in the timeline', async () => {
-    // Get the current timeline canvas' pixels - use a set to just determine that non-0 RGB values exist
-    const doPixelsExist: boolean = await setup.page.evaluate(() => {
-      const canvas = document.querySelector('canvas');
-      if (canvas !== null && canvas !== undefined) {
-        const context = canvas.getContext('2d');
-        if (context !== null && context !== undefined) {
-          const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
-          const pixelData = Array.from(imageData.data);
-          return pixelData.length > 0 ? true : false;
-          // Assert that the number of unique RGB pixel values for the canvas is more than 0 (i.e., not empty)
-        }
-      }
-      return false;
-    });
-
-    expect(doPixelsExist).toBeTruthy();
+    expect(await anyCanvasHasContent(setup.page, '[data-component-name="TimelinePanel"] canvas')).toBeTruthy();
   });
 
   test('Linked derivation groups should be expandable in panel', async () => {
diff --git a/e2e-tests/tests/simulation.test.ts b/e2e-tests/tests/simulation.test.ts
index ca648aa331..c1617f88cb 100644
--- a/e2e-tests/tests/simulation.test.ts
+++ b/e2e-tests/tests/simulation.test.ts
@@ -2,6 +2,7 @@ import test, { expect } from '@playwright/test';
 import { Status } from '../../src/enums/status.js';
 import { PanelNames } from '../fixtures/Plan.js';
 import { setupTest, teardownTest, type FullSetupResult } from '../utilities/api.js';
+import { anyCanvasHasContent } from '../utilities/canvas.js';
 
 let setup: FullSetupResult;
 
@@ -61,9 +62,31 @@ test.describe.serial('Simulation', async () => {
     await setup.plan.showPanel(PanelNames.SIMULATION, true);
   });
 
+  // Smoke test for the windowed-pull pipeline: indicator settles cleanly and
+  // canvases render non-transparent content (catches the "blank plot" bug an
+  // indicator-only check would miss).
+  test(`Streaming pipeline: indicator settles + canvases render across two re-sims`, async () => {
+    const timelineErrorIndicator = setup.plan.page.getByRole('status', { name: 'Timeline data error' });
+    const timelineLoadingIndicator = setup.plan.page.getByRole('status', { name: 'Timeline loading' });
+    const timelineCanvasContent = () => anyCanvasHasContent(setup.page, '[data-component-name="TimelinePanel"] canvas');
+
+    await setup.plan.reRunSimulation();
+    await expect(timelineErrorIndicator).not.toBeVisible();
+    await expect(timelineLoadingIndicator).not.toBeVisible();
+    await expect.poll(timelineCanvasContent, { timeout: 10000 }).toBe(true);
+
+    await setup.plan.reRunSimulation();
+    await expect(timelineErrorIndicator).not.toBeVisible();
+    await expect(timelineLoadingIndicator).not.toBeVisible();
+    await expect.poll(timelineCanvasContent, { timeout: 10000 }).toBe(true);
+  });
+
   test(`Plans with an invalid activity should fail simulation`, async () => {
+    const timelineLoadingIndicator = setup.plan.page.getByRole('status', { name: 'Timeline loading' });
     await setup.plan.addActivity('BakeBananaBread');
     await setup.plan.runSimulation(Status.Failed);
+    // Regression: indicator must settle for terminal-null sims too.
+    await expect(timelineLoadingIndicator).not.toBeVisible();
   });
 
   test(`Modified plans should indicate that simulation is out of date`, async () => {
diff --git a/e2e-tests/utilities/canvas.ts b/e2e-tests/utilities/canvas.ts
new file mode 100644
index 0000000000..5c4af40cd4
--- /dev/null
+++ b/e2e-tests/utilities/canvas.ts
@@ -0,0 +1,25 @@
+import type { Page } from '@playwright/test';
+
+/**
+ * True if any canvas matched by `selector` has a pixel with non-zero alpha.
+ * Stronger than checking the canvas exists — a transparent canvas would
+ * pass that. Pair with `expect.poll` for post-async-update checks.
+ */
+export function anyCanvasHasContent(page: Page, selector: string = 'canvas'): Promise<boolean> {
+  return page.evaluate(sel => {
+    const canvases = document.querySelectorAll<HTMLCanvasElement>(sel);
+    for (const canvas of Array.from(canvases)) {
+      const ctx = canvas.getContext('2d');
+      if (!ctx) {
+        continue;
+      }
+      const data = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
+      for (let i = 3; i < data.length; i += 4) {
+        if (data[i] > 0) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }, selector);
+}
diff --git a/src/components/ResourceList.svelte b/src/components/ResourceList.svelte
index 81342c9781..a239a4c5a7 100644
--- a/src/components/ResourceList.svelte
+++ b/src/components/ResourceList.svelte
@@ -4,12 +4,7 @@
   import CloseIcon from '@nasa-jpl/stellar/icons/close.svg?component';
   import UploadIcon from '@nasa-jpl/stellar/icons/upload.svg?component';
   import { plan } from '../stores/plan';
-  import {
-    allResourceTypes,
-    fetchingResourcesExternal,
-    resourceTypesLoading,
-    simulationDatasetId,
-  } from '../stores/simulation';
+  import { allResourceTypes, resourceTypesLoading, simulationDatasetId } from '../stores/simulation';
   import type { User } from '../types/app';
   import type { ResourceType } from '../types/simulation';
   import type { TimelineItemType } from '../types/timeline';
@@ -34,7 +29,7 @@
   let loading: boolean = false;
 
   $: resourceDataTypes = [...new Set($allResourceTypes.map(t => t.schema.type))];
-  $: loading = $fetchingResourcesExternal || $resourceTypesLoading;
+  $: loading = $resourceTypesLoading;
   $: if (user !== null && $plan !== null) {
     hasUploadPermission = featurePermissions.externalResources.canCreate(user, $plan);
   }
diff --git a/src/components/timeline/Row.svelte b/src/components/timeline/Row.svelte
index 4c8ab3eac7..d96962c6a1 100644
--- a/src/components/timeline/Row.svelte
+++ b/src/components/timeline/Row.svelte
@@ -4,24 +4,19 @@
   import type { ScaleTime } from 'd3-scale';
   import { select, type Selection } from 'd3-selection';
   import { zoom as d3Zoom, zoomIdentity, type D3ZoomEvent, type ZoomBehavior, type ZoomTransform } from 'd3-zoom';
-  import { createEventDispatcher } from 'svelte';
+  import { createEventDispatcher, onDestroy } from 'svelte';
   import FilterWithXIcon from '../../assets/filter-with-x.svg?component';
   import { ViewDefaultDiscreteOptions } from '../../constants/view';
-  import { Status } from '../../enums/status';
   import { activityArgumentDefaultsMap } from '../../stores/activities';
-  import { catchError, logMessage } from '../../stores/errors';
   import {
     derivationGroupVisibilityMap,
     externalSources,
     planDerivationGroupLinks,
   } from '../../stores/external-source';
   import { planModelActivityTypes } from '../../stores/plan';
-  import {
-    externalResources,
-    fetchingResourcesExternal,
-    resourceTypes,
-    resourceTypesLoading,
-  } from '../../stores/simulation';
+  import { createExternalResourceSubscription } from '../../stores/externalResource';
+  import { createProfileSubscription } from '../../stores/profile';
+  import { resourceTypes, resourceTypesLoading } from '../../stores/simulation';
   import { selectedRow, viewAddFilterToRow } from '../../stores/views';
   import type {
     ActivityDirective,
@@ -66,8 +61,6 @@
   import { getExternalEventRowId } from '../../utilities/externalEvents';
   import { classNames } from '../../utilities/generic';
   import { showConfirmActivityCreationModal } from '../../utilities/modal';
-  import { sampleProfiles } from '../../utilities/resources';
-  import { getSimulationStatus } from '../../utilities/simulation';
   import { pluralize } from '../../utilities/text';
   import { getDoyTime } from '../../utilities/time';
   import {
@@ -220,7 +213,7 @@
     }
   });
 
-  $: if (plan && simulationDataset !== null && layers && $externalResources && !$resourceTypesLoading) {
+  $: if (plan && simulationDataset !== null && layers && !$resourceTypesLoading) {
     const simulationDatasetId = simulationDataset.dataset_id;
     const resourceNamesSet = new Set<string>();
     layers.map(layer => {
@@ -232,120 +225,66 @@
     });
     const resourceNames = Array.from(resourceNamesSet);
 
-    // Cancel and delete unused and stale requests as well as any external resources that
-    // are not in the list of current external resources
+    // Drop entries no longer referenced by any layer or whose sim dataset
+    // changed. Both factories own their own registry cleanup on unsubscribe.
     Object.entries(resourceRequestMap).forEach(([key, value]) => {
-      if (
-        resourceNames.indexOf(key) < 0 ||
-        value.simulationDatasetId !== simulationDatasetId ||
-        (value.type === 'external' && !$resourceTypes.find(type => type.name === name))
-      ) {
-        value.controller?.abort();
+      if (resourceNames.indexOf(key) < 0 || value.simulationDatasetId !== simulationDatasetId) {
+        value.unsubscribe?.();
         delete resourceRequestMap[key];
         resourceRequestMap = { ...resourceRequestMap };
       }
     });
 
-    // Only update if simulation is complete
-    if (
-      getSimulationStatus(simulationDataset) === Status.Complete ||
-      getSimulationStatus(simulationDataset) === Status.Canceled
-    ) {
-      const startTimeYmd = simulationDataset?.simulation_start_time ?? plan.start_time;
-      resourceNames.forEach(async name => {
-        // Check if resource is external
-        const isExternal = !$resourceTypes.find(type => type.name === name);
-        if (isExternal) {
-          // Handle external datasets separately as they are globally loaded and subscribed to
-          let resource = null;
-          if (!$fetchingResourcesExternal) {
-            resource = $externalResources.find(resource => resource.name === name) || null;
-          }
-          let error = !resource && !$fetchingResourcesExternal ? 'External Profile not Found' : '';
-
-          resourceRequestMap = {
-            ...resourceRequestMap,
-            [name]: {
-              ...resourceRequestMap[name],
-              error,
-              loading: $fetchingResourcesExternal,
-              resource,
-              simulationDatasetId,
-              type: 'external',
-            },
-          };
-        } else {
-          // Skip matching resources requests that have already been added for this simulation
-          if (
-            resourceRequestMap[name] &&
-            simulationDatasetId === resourceRequestMap[name].simulationDatasetId &&
-            (resourceRequestMap[name].loading || resourceRequestMap[name].error || resourceRequestMap[name].resource)
-          ) {
-            return;
-          }
+    const startTimeYmd = simulationDataset?.simulation_start_time ?? plan.start_time;
+    resourceNames.forEach(name => {
+      if (
+        resourceRequestMap[name] &&
+        simulationDatasetId === resourceRequestMap[name].simulationDatasetId &&
+        resourceRequestMap[name].unsubscribe
+      ) {
+        return;
+      }
 
-          const controller = new AbortController();
-          resourceRequestMap = {
-            ...resourceRequestMap,
-            [name]: {
-              ...resourceRequestMap[name],
-              controller,
-              error: '',
-              loading: true,
-              resource: null,
-              simulationDatasetId,
-              type: 'internal',
+      const isExternal = !$resourceTypes.find(type => type.name === name);
+      const subscription = isExternal
+        ? createExternalResourceSubscription(simulationDatasetId, name, startTimeYmd, user)
+        : createProfileSubscription(simulationDatasetId, name, startTimeYmd, user);
+      const type: 'external' | 'internal' = isExternal ? 'external' : 'internal';
+      // Declared before .subscribe() so the closure in `unsubscribe` below
+      // doesn't lean on TDZ-via-const initialization order.
+      let storeUnsubscribe: (() => void) | null = null;
+      storeUnsubscribe = subscription.store.subscribe(({ error, loading, resource }) => {
+        resourceRequestMap = {
+          ...resourceRequestMap,
+          [name]: {
+            ...resourceRequestMap[name],
+            error,
+            loading,
+            resource,
+            simulationDatasetId,
+            type,
+            unsubscribe: () => {
+              storeUnsubscribe?.();
+              subscription.unsubscribe();
             },
-          };
-
-          let resource = null;
-          let error = '';
-          let aborted = false;
-          try {
-            const startTime = performance.now();
-            const response = await effects.getResource(simulationDatasetId, name, user, controller.signal);
-            const { profile } = response;
-            if (profile && profile.length === 1) {
-              resource = sampleProfiles([profile[0]], startTimeYmd)[0];
-              logMessage(
-                `Retrieved profile ${name} (${profile[0].profile_segments.length} segment${pluralize(profile[0].profile_segments.length)}) for simulation ${simulationDatasetId}.`,
-                '',
-                performance.now() - startTime,
-              );
-            } else {
-              throw new Error('Profile not Found');
-            }
-          } catch (e) {
-            const err = e as Error;
-            if (err.name === 'AbortError') {
-              aborted = true;
-            } else {
-              catchError(`Profile Download Failed for ${name}`, e as Error);
-              error = err.message;
-            }
-          } finally {
-            if (!aborted) {
-              resourceRequestMap = {
-                ...resourceRequestMap,
-                [name]: {
-                  ...resourceRequestMap[name],
-                  error,
-                  loading: false,
-                  resource,
-                },
-              };
-            }
-          }
-        }
+          },
+        };
       });
-    }
+    });
   } else if (simulationDataset === null) {
-    Object.entries(resourceRequestMap).forEach(([_key, value]) => {
-      value.controller?.abort();
+    Object.values(resourceRequestMap).forEach(value => {
+      value.unsubscribe?.();
     });
     resourceRequestMap = {};
   }
 
+  onDestroy(() => {
+    Object.values(resourceRequestMap).forEach(value => {
+      value.unsubscribe?.();
+    });
+    resourceRequestMap = {};
+  });
+
   $: onDragenter(dragenter);
   $: onDragleave(dragleave);
   $: onDragover(dragover);
@@ -384,6 +323,7 @@
   $: if (resourceRequestMap) {
     const newLoadedResources: Resource[] = [];
     const newLoadingErrors: string[] = [];
+    let anyLoading = false;
     Object.values(resourceRequestMap).forEach(resourceRequest => {
       if (resourceRequest.resource) {
         newLoadedResources.push(resourceRequest.resource);
@@ -391,14 +331,15 @@
       if (resourceRequest.error) {
         newLoadingErrors.push(resourceRequest.error);
       }
+      if (resourceRequest.loading) {
+        anyLoading = true;
+      }
     });
     loadedResources = newLoadedResources;
     resourceLoadingErrors = newLoadingErrors;
-
-    // Consider row to be loading if the number of completed resource requests (loaded or error state)
-    // is not equal to the total number of resource requests
-    anyResourcesLoading =
-      loadedResources.length + resourceLoadingErrors.length !== Object.keys(resourceRequestMap).length;
+    // Use per-request loading flag, not loaded+errored vs total: a request
+    // with both data and an error would be double-counted and stick true.
+    anyResourcesLoading = anyLoading;
   }
 
   // Compute scale domains for axes since it is optionally defined in the view
diff --git a/src/components/timeline/TimelinePanel.svelte b/src/components/timeline/TimelinePanel.svelte
index 482750ca08..42e7d7711d 100644
--- a/src/components/timeline/TimelinePanel.svelte
+++ b/src/components/timeline/TimelinePanel.svelte
@@ -50,6 +50,7 @@
   import Panel from '../ui/Panel.svelte';
   import PanelHeaderActions from '../ui/PanelHeaderActions.svelte';
   import Timeline from './Timeline.svelte';
+  import TimelineStatusIndicator from './TimelineStatusIndicator.svelte';
   import TimelineViewControls from './TimelineViewControls.svelte';
 
   export let user: User | null;
@@ -181,7 +182,10 @@
 
 <Panel padBody={false}>
   <svelte:fragment slot="header">
-    <div class="st-typography-medium timeline-title">Timeline</div>
+    <div class="timeline-title-group">
+      <div class="st-typography-medium timeline-title">Timeline</div>
+      <TimelineStatusIndicator />
+    </div>
     <PanelHeaderActions>
       <div class="header-actions timeline-icon-tray">
         <TimelineViewControls
@@ -280,6 +284,10 @@
 </Panel>
 
 <style>
+  .timeline-title-group {
+    align-items: center;
+    display: flex;
+  }
   .timeline-title {
     padding: 0px 4px;
     user-select: none;
diff --git a/src/components/timeline/TimelineStatusIndicator.svelte b/src/components/timeline/TimelineStatusIndicator.svelte
new file mode 100644
index 0000000000..e6683d8eba
--- /dev/null
+++ b/src/components/timeline/TimelineStatusIndicator.svelte
@@ -0,0 +1,82 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import { LoaderCircle, TriangleAlert } from 'lucide-svelte';
+  import { derived, type Readable } from 'svelte/store';
+  import { Status } from '../../enums/status';
+  import { activityDirectivesDB } from '../../stores/activities';
+  import { constraintRuns } from '../../stores/constraints';
+  import { selectedExternalEventsRaw } from '../../stores/external-event';
+  import { initialSpansLoading, simulationStatus } from '../../stores/simulation';
+  import { timelineResourcesErroring, timelineResourcesLoading } from '../../stores/timelineResourceStatus';
+  import { tooltip } from '../../utilities/tooltip';
+
+  type StatusError = { message: string; source: string };
+
+  // Profile subs flip out of `loading` on first batch; without this the
+  // indicator would hide mid-sim while data is still streaming.
+  const simulationStreaming: Readable<boolean> = derived(
+    simulationStatus,
+    $simulationStatus => $simulationStatus === Status.Pending || $simulationStatus === Status.Incomplete,
+  );
+
+  const loading: Readable<boolean> = derived(
+    [
+      timelineResourcesLoading,
+      initialSpansLoading,
+      activityDirectivesDB.loading,
+      constraintRuns.loading,
+      selectedExternalEventsRaw.loading,
+      simulationStreaming,
+    ],
+    values => values.some(Boolean),
+  );
+
+  const errors: Readable<StatusError[]> = derived(
+    [timelineResourcesErroring, activityDirectivesDB.error, constraintRuns.error, selectedExternalEventsRaw.error],
+    ([resourceErrs, directivesErr, constraintsErr, eventsErr]) => {
+      const out: StatusError[] = [];
+      resourceErrs.forEach(e => {
+        const label = e.kind === 'external' ? 'External profile' : 'Profile';
+        out.push({ message: e.error, source: `${label} ${e.name}` });
+      });
+      if (directivesErr) {
+        out.push({ message: directivesErr, source: 'Activity directives' });
+      }
+      if (constraintsErr) {
+        out.push({ message: constraintsErr, source: 'Constraint runs' });
+      }
+      if (eventsErr) {
+        out.push({ message: eventsErr, source: 'External events' });
+      }
+      return out;
+    },
+  );
+
+  $: errorCount = $errors.length;
+  $: hasError = errorCount > 0;
+  // `\n` renders as a line break — tooltip.css sets white-space: pre-line
+  // on .tippy-content globally.
+  $: errorTooltip = hasError ? $errors.map(e => `${e.source}: ${e.message}`).join('\n') : '';
+</script>
+
+{#if hasError}
+  <div
+    class="ml-2 inline-flex items-center gap-1 text-destructive"
+    use:tooltip={{ content: errorTooltip, placement: 'bottom' }}
+    role="status"
+    aria-label="Timeline data error"
+  >
+    <TriangleAlert size={14} />
+    <span class="text-xs font-medium">{errorCount}</span>
+  </div>
+{:else if $loading}
+  <div
+    class="ml-2 inline-flex items-center text-muted-foreground"
+    use:tooltip={{ content: 'Loading timeline data…', placement: 'bottom' }}
+    role="status"
+    aria-label="Timeline loading"
+  >
+    <LoaderCircle size={14} class="animate-spin" />
+  </div>
+{/if}
diff --git a/src/routes/plans/[id]/+page.svelte b/src/routes/plans/[id]/+page.svelte
index cee9d6c885..bf262be1de 100644
--- a/src/routes/plans/[id]/+page.svelte
+++ b/src/routes/plans/[id]/+page.svelte
@@ -117,8 +117,6 @@
   import {
     enableSimulation,
     externalResourceNames,
-    externalResources,
-    fetchingResourcesExternal,
     initialSpansLoading,
     resetSimulationStores,
     resourceTypes,
@@ -201,7 +199,6 @@
   let selectedSimulationStatus: Status | null;
   let windowWidth = 1600;
   let simulationDataAbortController: AbortController;
-  let resourcesExternalAbortController: AbortController;
   let schedulingStatusText: string = '';
   let lastSimulationDatasetId: number | null = null;
   let consolePaneApi: PaneAPI;
@@ -391,35 +388,17 @@
     initializeView({ ...data.initialView });
   }
 
-  $: if ($initialPlan && $planDatasets) {
-    const datasetNames = [];
-
+  // External profile names. The actual profile data is fetched on demand
+  // per visible row by createExternalResourceSubscription (see
+  // stores/externalResource.ts), driven off the same planDatasets sub.
+  $: if ($planDatasets) {
+    const names = new Set<string>();
     for (const dataset of $planDatasets) {
       for (const profile of dataset.dataset.profiles) {
-        datasetNames.push(profile.name);
+        names.add(profile.name);
       }
     }
-
-    $externalResourceNames = [...new Set(datasetNames)];
-
-    resourcesExternalAbortController?.abort();
-    resourcesExternalAbortController = new AbortController();
-    $fetchingResourcesExternal = true;
-    $externalResources = [];
-    effects
-      .getResourcesExternal(
-        $initialPlan.id,
-        $simulationDatasetId > -1 ? $simulationDatasetId : null,
-        $initialPlan.start_time,
-        get(user),
-        resourcesExternalAbortController.signal,
-      )
-      .then(({ aborted, resources }) => {
-        if (!aborted) {
-          $externalResources = resources;
-          $fetchingResourcesExternal = false;
-        }
-      });
+    $externalResourceNames = [...names];
   }
 
   $: if ($planId > -1) {
@@ -450,6 +429,9 @@
     simulationDataAbortController?.abort();
     $spans = null;
     $simulationEvents = null;
+    // Only the Complete branch fetches spans; clear the flag in every other
+    // branch so the global indicator doesn't spin forever on failed/no-sim.
+    $initialSpansLoading = false;
   }
 
   $: compactNavMode = windowWidth < 1200;
@@ -490,8 +472,8 @@
   $: if (typeof $planModelId === 'number' && browser) {
     // Asynchronously fetch resource types
     $resourceTypesLoading = true;
-    effects.getResourceTypes($planModelId, get(user)).then(initialResourceTypes => {
-      $resourceTypes = initialResourceTypes;
+    effects.getResourceTypes($planModelId, get(user)).then(modelResourceTypes => {
+      $resourceTypes = modelResourceTypes;
       $resourceTypesLoading = false;
     });
   }
diff --git a/src/stores/__mocks__/plan.mock.ts b/src/stores/__mocks__/plan.mock.ts
index 760eb81ef9..84d16384ce 100644
--- a/src/stores/__mocks__/plan.mock.ts
+++ b/src/stores/__mocks__/plan.mock.ts
@@ -2,6 +2,7 @@ import { derived, writable, type Readable, type Writable } from 'svelte/store';
 import type { ActivityType } from '../../types/activity';
 import type { ModelSlim } from '../../types/model';
 import type { Plan, PlanMergeRequest, PlanMetadata } from '../../types/plan';
+import type { PlanDataset } from '../../types/simulation';
 import type { Tag } from '../../types/tags';
 import type { TimeRange } from '../../types/timeline';
 
@@ -52,6 +53,8 @@ export const planModelRevision: Readable<number> = derived(initialPlan, $plan =>
 
 export const activityTypes = writable<ActivityType[]>([]);
 
+export const planDatasets = writable<PlanDataset[]>([]);
+
 export const planTags = writable<Tag[]>([]);
 
 export const models = writable<ModelSlim[]>([]);
diff --git a/src/stores/externalResource.test.ts b/src/stores/externalResource.test.ts
new file mode 100644
index 0000000000..98e8153b00
--- /dev/null
+++ b/src/stores/externalResource.test.ts
@@ -0,0 +1,334 @@
+import { writable, type Subscriber, type Writable } from 'svelte/store';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import type { PlanDataset, Profile, ProfileSegment, Resource } from '../types/simulation';
+
+const getExternalProfileSegmentsSinceMock = vi.fn();
+vi.mock('../utilities/effects', () => ({
+  default: {
+    getExternalProfileSegmentsSince: (...args: any[]) => getExternalProfileSegmentsSinceMock(...args),
+  },
+}));
+
+// A planDatasets mock that mimics the gqlSubscribable shape used by the
+// factory: a primary store + a `.loading` substore. We can't import the real
+// gqlSubscribable here because it pulls in `$env/dynamic/public` via the
+// shared WebSocket client, which Vitest can't satisfy.
+type PlanDatasetsMock = {
+  _setLoading: (v: boolean) => void;
+  loading: { subscribe: (s: Subscriber<boolean>) => () => void };
+  set: (v: PlanDataset[]) => void;
+  subscribe: (s: Subscriber<PlanDataset[]>) => () => void;
+};
+
+const planDatasetsValue: Writable<PlanDataset[]> = writable([]);
+const planDatasetsLoading: Writable<boolean> = writable(true);
+const planDatasetsMock: PlanDatasetsMock = {
+  _setLoading: v => planDatasetsLoading.set(v),
+  loading: { subscribe: planDatasetsLoading.subscribe },
+  set: v => planDatasetsValue.set(v),
+  subscribe: planDatasetsValue.subscribe,
+};
+vi.mock('./plan', () => ({
+  planDatasets: planDatasetsMock,
+}));
+
+vi.mock('./errors', () => ({
+  catchError: vi.fn(),
+  logMessage: vi.fn(),
+}));
+
+function makeProfile(opts: { duration: string; id: number; name: string }): Profile {
+  return {
+    dataset_id: 0,
+    duration: opts.duration,
+    id: opts.id,
+    name: opts.name,
+    profile_segments: [],
+    type: { schema: { type: 'string' } as any, type: 'discrete' },
+  };
+}
+
+function makePlanDataset(opts: {
+  datasetId: number;
+  offset?: string;
+  profiles: Profile[];
+  simDatasetId?: number | null;
+}): PlanDataset {
+  return {
+    dataset: { profiles: opts.profiles },
+    dataset_id: opts.datasetId,
+    offset_from_plan_start: opts.offset ?? '00:00:00',
+    simulation_dataset_id: opts.simDatasetId ?? null,
+  };
+}
+
+function segments(specs: Array<{ start_offset: string; value: any }>): ProfileSegment[] {
+  return specs.map(s => ({
+    dataset_id: 0,
+    dynamics: s.value,
+    is_gap: false,
+    profile_id: 0,
+    start_offset: s.start_offset,
+  }));
+}
+
+async function flushPromises() {
+  await Promise.resolve();
+  await new Promise(resolve => setTimeout(resolve, 0));
+}
+
+describe('createExternalResourceSubscription', () => {
+  let createExternalResourceSubscription: typeof import('./externalResource').createExternalResourceSubscription;
+  // Track subs across the test so afterEach can clean up even if a test
+  // fails before its inline unsubscribe — a leaked sub would steal mock
+  // slots from the next test.
+  let activeSubs: Array<{ unsubscribe: () => void }> = [];
+  function makeSub(...args: Parameters<typeof createExternalResourceSubscription>) {
+    const sub = createExternalResourceSubscription(...args);
+    activeSubs.push(sub);
+    return sub;
+  }
+
+  beforeEach(async () => {
+    getExternalProfileSegmentsSinceMock.mockReset();
+    planDatasetsValue.set([]);
+    planDatasetsLoading.set(true);
+    vi.resetModules();
+    // Dynamic import so vi.resetModules() takes effect — the factory closes
+    // over the mocked planDatasets/effects at import time.
+    const mod = await import('./externalResource');
+    createExternalResourceSubscription = mod.createExternalResourceSubscription;
+  });
+
+  afterEach(() => {
+    activeSubs.forEach(s => s.unsubscribe());
+    activeSubs = [];
+    getExternalProfileSegmentsSinceMock.mockReset();
+  });
+
+  test('settling → found: first fetch resolves to a Resource', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValue(
+      segments([
+        { start_offset: '00:00:00', value: 'A' },
+        { start_offset: '00:01:00', value: 'B' },
+      ]),
+    );
+
+    // Sub created while planDatasets is still loading — must stay in
+    // loading state and NOT flash an error.
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    let last: any = null;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.loading).toBe(true);
+    expect(last.error).toBe('');
+
+    // Subscription settles with a populated planDatasets that has the name.
+    const profile = makeProfile({ duration: '00:02:00', id: 7, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    planDatasetsLoading.set(false);
+    await flushPromises();
+
+    expect(last.loading).toBe(false);
+    expect(last.error).toBe('');
+    expect(last.resource).not.toBeNull();
+    expect((last.resource as Resource).values.length).toBeGreaterThan(0);
+  });
+
+  test('race-defer: settling → missing → found does NOT surface the missing error', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValue(segments([{ start_offset: '00:00:00', value: 'A' }]));
+
+    const profile = makeProfile({ duration: '00:01:00', id: 9, name: 'r' });
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    const seen: Array<{ error: string; loading: boolean }> = [];
+    sub.store.subscribe(s => {
+      seen.push({ error: s.error, loading: s.loading });
+    });
+
+    // The actual race: gqlSubscribable.next() flips `.loading` before the
+    // value subscribers fire, so the derived briefly sees loading=false +
+    // value=[]. Emulate that ordering: flip loading first (within the same
+    // synchronous frame), then set the value. The microtask defer should
+    // cancel the missing emit.
+    planDatasetsLoading.set(false);
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    await flushPromises();
+
+    expect(seen.every(s => s.error === '')).toBe(true);
+  });
+
+  test('settled missing → error fires after microtask', async () => {
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    let last: any = null;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+
+    // Settle with no matching profile and let the microtask run.
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [] })]);
+    planDatasetsLoading.set(false);
+    await flushPromises();
+
+    expect(last.error).toBe('Resource not found in attached external datasets');
+    expect(last.loading).toBe(false);
+    expect(last.resource).toBeNull();
+  });
+
+  test('sim-tied plan_dataset row is preferred over plan-level (null sim) row', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValue(segments([{ start_offset: '00:00:00', value: 'A' }]));
+
+    const profile = makeProfile({ duration: '00:02:00', id: 11, name: 'r' });
+    planDatasetsValue.set([
+      makePlanDataset({ datasetId: 1, profiles: [profile], simDatasetId: null }),
+      makePlanDataset({ datasetId: 2, profiles: [profile], simDatasetId: 42 }),
+    ]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(42, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock).toHaveBeenCalled();
+    const [firstCall] = getExternalProfileSegmentsSinceMock.mock.calls;
+    expect(firstCall[0]).toBe(2); // datasetId from the sim-tied row, not the plan-level one
+  });
+
+  test('plan-level (null sim) row is preferred over a non-matching sim row', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValue(segments([{ start_offset: '00:00:00', value: 'A' }]));
+
+    const profile = makeProfile({ duration: '00:02:00', id: 11, name: 'r' });
+    planDatasetsValue.set([
+      makePlanDataset({ datasetId: 3, profiles: [profile], simDatasetId: 99 }),
+      makePlanDataset({ datasetId: 4, profiles: [profile], simDatasetId: null }),
+    ]);
+    planDatasetsLoading.set(false);
+
+    // sub watches sim 42; neither row matches, so plan-level (datasetId=4) wins.
+    const sub = makeSub(42, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    const [firstCall] = getExternalProfileSegmentsSinceMock.mock.calls;
+    expect(firstCall[0]).toBe(4);
+  });
+
+  test('duration advance triggers a refetch with the last seen offset as sinceOffset', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValueOnce(
+      segments([
+        { start_offset: '00:00:00', value: 'A' },
+        { start_offset: '00:00:30', value: 'B' },
+      ]),
+    );
+
+    const profile = makeProfile({ duration: '00:01:00', id: 11, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[0][2]).toBe('-00:00:01');
+
+    // Duration grows (backend appended more segments). Trigger via a
+    // metadata push with the new duration.
+    getExternalProfileSegmentsSinceMock.mockResolvedValueOnce(segments([{ start_offset: '00:01:00', value: 'C' }]));
+    planDatasetsValue.set([
+      makePlanDataset({ datasetId: 1, profiles: [makeProfile({ duration: '00:02:00', id: 11, name: 'r' })] }),
+    ]);
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[1][2]).toBe('00:00:30');
+  });
+
+  test('unchanged metadata does NOT trigger a refetch', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValueOnce(segments([{ start_offset: '00:00:00', value: 'A' }]));
+
+    const profile = makeProfile({ duration: '00:01:00', id: 11, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock).toHaveBeenCalledTimes(1);
+
+    // Re-emit identical metadata (same duration, same row). Should not
+    // re-refetch — would otherwise hammer the backend on every metadata
+    // tick during ingestion.
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('profile-row switch resets accumulator and refetches with sentinel offset', async () => {
+    getExternalProfileSegmentsSinceMock.mockResolvedValueOnce(segments([{ start_offset: '00:00:30', value: 'A' }]));
+
+    const profileA = makeProfile({ duration: '00:01:00', id: 11, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profileA] })]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[0][2]).toBe('-00:00:01');
+
+    // A different profile under the same name (different id and dataset)
+    // wins on the next tick. Accumulator must reset and refetch with the
+    // sentinel.
+    getExternalProfileSegmentsSinceMock.mockResolvedValueOnce(segments([{ start_offset: '00:00:00', value: 'B' }]));
+    const profileB = makeProfile({ duration: '00:01:00', id: 99, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 2, profiles: [profileB] })]);
+    await flushPromises();
+
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[1][0]).toBe(2);
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[1][1]).toBe(99);
+    expect(getExternalProfileSegmentsSinceMock.mock.calls[1][2]).toBe('-00:00:01');
+  });
+
+  test('refetch error surfaces in state', async () => {
+    getExternalProfileSegmentsSinceMock.mockRejectedValue(new Error('boom'));
+
+    const profile = makeProfile({ duration: '00:01:00', id: 11, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    let last: any = null;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.error).toBe('boom');
+    expect(last.loading).toBe(false);
+  });
+
+  test('dispose during in-flight refetch: no state mutations after unsubscribe', async () => {
+    let resolveFetch: (v: ProfileSegment[] | null) => void = () => {};
+    getExternalProfileSegmentsSinceMock.mockReturnValue(new Promise<ProfileSegment[] | null>(r => (resolveFetch = r)));
+
+    const profile = makeProfile({ duration: '00:01:00', id: 11, name: 'r' });
+    planDatasetsValue.set([makePlanDataset({ datasetId: 1, profiles: [profile] })]);
+    planDatasetsLoading.set(false);
+
+    const sub = makeSub(-1, 'r', '2024-01-01T00:00:00', null);
+    let updates = 0;
+    sub.store.subscribe(() => {
+      updates++;
+    });
+    const baseline = updates;
+
+    sub.unsubscribe();
+    resolveFetch(segments([{ start_offset: '00:00:00', value: 'A' }]));
+    await flushPromises();
+
+    expect(updates).toBe(baseline);
+  });
+});
diff --git a/src/stores/externalResource.ts b/src/stores/externalResource.ts
new file mode 100644
index 0000000000..f19fc89418
--- /dev/null
+++ b/src/stores/externalResource.ts
@@ -0,0 +1,275 @@
+import { derived, writable, type Readable } from 'svelte/store';
+import type { User } from '../types/app';
+import type { Profile, ProfileSegment, Resource } from '../types/simulation';
+import effects from '../utilities/effects';
+import { sampleProfiles } from '../utilities/resources';
+import { catchError } from './errors';
+import { planDatasets } from './plan';
+import {
+  acquireTimelineResource,
+  releaseTimelineResource,
+  setTimelineResourceState,
+  type TimelineResourceState,
+} from './timelineResourceStatus';
+
+export type ExternalResourceSubscription = {
+  store: Readable<TimelineResourceState>;
+  unsubscribe: () => void;
+};
+
+// First-fetch sentinel: smaller than any real start_offset, so the windowed
+// query returns every existing segment. Postgres interval syntax (HH:MM:SS) —
+// Hasura's interval scalar rejects ISO 8601.
+const INITIAL_SINCE = '-00:00:01';
+
+type ProfileMetadata = {
+  datasetId: number;
+  duration: string;
+  offsetFromPlanStart: string;
+  profileId: number;
+  type: Profile['type'];
+};
+
+/**
+ * Per-(simDatasetId, name) live view of an external dataset resource.
+ * Mirrors createProfileSubscription: subscribes to a metadata source
+ * (planDatasets), windowed-pulls segments past the last seen start_offset
+ * whenever metadata advances, accumulates, and re-samples into a Resource.
+ *
+ * `simDatasetId` is the current simulation's dataset id (or -1 for plan-
+ * level). It's used to pick *which* plan_dataset row owns this name when
+ * multiple rows define it — preferring the row tied to the active sim, then
+ * the plan-level (null) row.
+ */
+export function createExternalResourceSubscription(
+  simDatasetId: number,
+  name: string,
+  planStartTimeYmd: string,
+  user: User | null,
+): ExternalResourceSubscription {
+  const initialState: TimelineResourceState = { error: '', loading: true, resource: null };
+  acquireTimelineResource(simDatasetId, name);
+  setTimelineResourceState(simDatasetId, name, 'external', initialState);
+  const state = writable<TimelineResourceState>(initialState);
+  function setState(next: TimelineResourceState) {
+    state.set(next);
+    setTimelineResourceState(simDatasetId, name, 'external', next);
+  }
+
+  const accumulator: ProfileSegment[] = [];
+  let sinceOffset = INITIAL_SINCE;
+  let resolved = false;
+  let lastError = '';
+  let inFlight = false;
+  // Re-fire once from the finally block if a refetch was requested while
+  // another was in flight, so we don't miss the tail if the request
+  // happened to be the last meaningful trigger (e.g. ingestion finished
+  // while we were already fetching).
+  let pendingRefetch = false;
+  // Tracks the metadata snapshot we last refetched against, so we only
+  // refire when duration advances or the chosen plan_dataset row changes.
+  let lastMeta: ProfileMetadata | null = null;
+  let currentMeta: ProfileMetadata | null = null;
+  let disposed = false;
+  const abortController = new AbortController();
+  const unsubscribers: Array<() => void> = [];
+
+  // Live metadata slice: pick the right plan_dataset row for (simDatasetId,
+  // name). Preference order: sim-matching > plan-level (null sim) > first
+  // encountered. Also surfaces "settling" so we don't flash a "not found"
+  // error during the initial subscription bootstrap.
+  type MetaResolution = { kind: 'settling' } | { kind: 'missing' } | { kind: 'found'; meta: ProfileMetadata };
+
+  type Candidate = { datasetId: number; offset: string; profile: Profile };
+
+  const metadata: Readable<MetaResolution> = derived(
+    [planDatasets, planDatasets.loading],
+    ([$planDatasets, $loading]): MetaResolution => {
+      if ($loading) {
+        return { kind: 'settling' };
+      }
+      let plan: Candidate | null = null;
+      let planLevel: Candidate | null = null;
+      let fallback: Candidate | null = null;
+      for (const pd of $planDatasets) {
+        const profile = pd.dataset.profiles.find(p => p.name === name);
+        if (!profile) {
+          continue;
+        }
+        const candidate: Candidate = { datasetId: pd.dataset_id, offset: pd.offset_from_plan_start, profile };
+        const simId = pd.simulation_dataset_id;
+        if (simDatasetId > -1 && simId === simDatasetId) {
+          plan = candidate;
+          break;
+        }
+        if (simId === null && planLevel === null) {
+          planLevel = candidate;
+        }
+        if (fallback === null) {
+          fallback = candidate;
+        }
+      }
+      const picked = plan ?? planLevel ?? fallback;
+      if (!picked) {
+        return { kind: 'missing' };
+      }
+      return {
+        kind: 'found',
+        meta: {
+          datasetId: picked.datasetId,
+          duration: picked.profile.duration,
+          offsetFromPlanStart: picked.offset,
+          profileId: picked.profile.id,
+          type: picked.profile.type,
+        },
+      };
+    },
+  );
+
+  function emit() {
+    if (disposed) {
+      return;
+    }
+    let resource: Resource | null = null;
+    if (currentMeta && resolved) {
+      const synthesised: Profile = {
+        dataset_id: currentMeta.datasetId,
+        duration: currentMeta.duration,
+        id: currentMeta.profileId,
+        name,
+        profile_segments: accumulator,
+        type: currentMeta.type,
+      };
+      resource = sampleProfiles([synthesised], planStartTimeYmd, currentMeta.offsetFromPlanStart)[0] ?? null;
+    }
+    const nextState: TimelineResourceState = { error: lastError, loading: !resolved && !lastError, resource };
+    setState(nextState);
+  }
+
+  async function refetch() {
+    if (disposed || !currentMeta) {
+      return;
+    }
+    if (inFlight) {
+      pendingRefetch = true;
+      return;
+    }
+    inFlight = true;
+    try {
+      const segments = await effects.getExternalProfileSegmentsSince(
+        currentMeta.datasetId,
+        currentMeta.profileId,
+        sinceOffset,
+        user,
+        abortController.signal,
+      );
+      if (disposed) {
+        return;
+      }
+      if (segments && segments.length > 0) {
+        accumulator.push(...segments);
+        sinceOffset = segments[segments.length - 1].start_offset;
+      }
+      resolved = true;
+      lastError = '';
+      emit();
+    } catch (e) {
+      if (disposed) {
+        return;
+      }
+      const err = e as Error;
+      if (err.name === 'AbortError') {
+        return;
+      }
+      lastError = err.message || 'External profile fetch failed';
+      emit();
+    } finally {
+      inFlight = false;
+      if (pendingRefetch && !disposed) {
+        pendingRefetch = false;
+        refetch();
+      }
+    }
+  }
+
+  function resetForNewProfile() {
+    accumulator.length = 0;
+    sinceOffset = INITIAL_SINCE;
+    resolved = false;
+  }
+
+  // Race-defer for missing: gqlSubscribable.next() flips `.loading` to
+  // false BEFORE propagating the new value to subscribers. So the derived
+  // briefly sees `{loading: false, planDatasets: []}` on the first tick and
+  // would emit 'missing' just before the value update arrives as 'found'.
+  // Defer the missing verdict by a microtask so a synchronously-following
+  // 'found' can cancel it. Genuine misconfigs still surface — the microtask
+  // flushes with `pendingMissing` still true.
+  let pendingMissing = false;
+
+  unsubscribers.push(
+    metadata.subscribe(next => {
+      if (disposed) {
+        return;
+      }
+      if (next.kind === 'settling') {
+        pendingMissing = false;
+        return;
+      }
+      if (next.kind === 'missing') {
+        pendingMissing = true;
+        queueMicrotask(() => {
+          if (disposed || !pendingMissing) {
+            return;
+          }
+          pendingMissing = false;
+          currentMeta = null;
+          lastMeta = null;
+          resetForNewProfile();
+          lastError = 'Resource not found in attached external datasets';
+          catchError(`Unable to load resource "${name}"`, new Error(lastError));
+          emit();
+        });
+        return;
+      }
+      pendingMissing = false;
+      const { meta } = next;
+      currentMeta = meta;
+      // If we switched to a different profile row (different dataset or id),
+      // reset accumulator and sinceOffset before refetching.
+      const switched =
+        lastMeta !== null && (lastMeta.datasetId !== meta.datasetId || lastMeta.profileId !== meta.profileId);
+      if (switched) {
+        resetForNewProfile();
+      }
+      const durationAdvanced = lastMeta === null || lastMeta.duration !== meta.duration;
+      lastMeta = meta;
+      // Assumption: external profiles only grow via `duration` advancement.
+      // If a backend ever appends segments without bumping duration, those
+      // segments are silently missed here — refetches are gated on duration.
+      // Static-at-write-time today; revisit if a "live external dataset"
+      // feature ships.
+      if (switched || durationAdvanced || !resolved) {
+        refetch();
+      } else if (lastError) {
+        // Re-emit to clear lingering error if metadata is now clean.
+        emit();
+      }
+      // Otherwise: meta unchanged, no error pending, no need to re-sample
+      // the full accumulator and re-push identical state downstream.
+    }),
+  );
+
+  return {
+    store: { subscribe: state.subscribe },
+    unsubscribe: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      releaseTimelineResource(simDatasetId, name);
+      abortController.abort();
+      unsubscribers.forEach(unsub => unsub());
+    },
+  };
+}
diff --git a/src/stores/profile.test.ts b/src/stores/profile.test.ts
new file mode 100644
index 0000000000..46e6d03b83
--- /dev/null
+++ b/src/stores/profile.test.ts
@@ -0,0 +1,258 @@
+import { writable, type Writable } from 'svelte/store';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import type { Profile, Resource, SimulationDataset } from '../types/simulation';
+
+const getProfileSinceMock = vi.fn();
+vi.mock('../utilities/effects', () => ({
+  default: {
+    getProfileSince: (...args: any[]) => getProfileSinceMock(...args),
+  },
+}));
+
+const simulationDatasetMock: Writable<SimulationDataset | null> = writable(null);
+vi.mock('./simulation', () => ({
+  simulationDataset: simulationDatasetMock,
+}));
+
+// Stub: `./errors` transitively pulls `$env/dynamic/public` via requests.ts.
+vi.mock('./errors', () => ({
+  catchError: vi.fn(),
+  logMessage: vi.fn(),
+}));
+
+function setSimRunning(datasetId: number, extent: string = '00:00:00') {
+  simulationDatasetMock.set({
+    canceled: false,
+    dataset_id: datasetId,
+    extent: { extent },
+    status: 'incomplete',
+  } as SimulationDataset);
+}
+function setSimComplete(datasetId: number, extent: string = '00:10:00') {
+  simulationDatasetMock.set({
+    canceled: false,
+    dataset_id: datasetId,
+    extent: { extent },
+    status: 'success',
+  } as SimulationDataset);
+}
+
+function makeProfile(opts: { duration: string; segments: Array<{ start_offset: string; value: any }> }): Profile {
+  return {
+    dataset_id: 1,
+    duration: opts.duration,
+    id: 7,
+    name: 'r',
+    profile_segments: opts.segments.map(s => ({
+      dataset_id: 1,
+      dynamics: s.value,
+      is_gap: false,
+      profile_id: 7,
+      start_offset: s.start_offset,
+    })),
+    type: { schema: { type: 'string' } as any, type: 'discrete' },
+  };
+}
+
+async function flushPromises() {
+  await Promise.resolve();
+  await new Promise(resolve => setTimeout(resolve, 0));
+}
+
+describe('createProfileSubscription', () => {
+  let createProfileSubscription: typeof import('./profile').createProfileSubscription;
+  // Track subs so afterEach cleanup runs even if a test fails before its
+  // inline unsubscribe — a leaked sub would steal mockResolvedValueOnce
+  // slots from the next test.
+  let activeSubs: Array<{ unsubscribe: () => void }> = [];
+  function makeSub(...args: Parameters<typeof createProfileSubscription>) {
+    const sub = createProfileSubscription(...args);
+    activeSubs.push(sub);
+    return sub;
+  }
+
+  beforeEach(async () => {
+    getProfileSinceMock.mockReset();
+    simulationDatasetMock.set(null);
+    // `simulationDatasetMock` is module-scoped (top of file) so it survives
+    // resetModules — both the prior import and the fresh import below see
+    // the same writable. The fresh import is what we resubscribe against
+    // for each test.
+    vi.resetModules();
+    const mod = await import('./profile');
+    createProfileSubscription = mod.createProfileSubscription;
+  });
+
+  afterEach(() => {
+    activeSubs.forEach(s => s.unsubscribe());
+    activeSubs = [];
+    getProfileSinceMock.mockReset();
+  });
+
+  test('first refetch with full data emits a Resource and clears loading', async () => {
+    const profile = makeProfile({
+      duration: '00:02:00',
+      segments: [{ start_offset: '00:00:00', value: 'A' }],
+    });
+    getProfileSinceMock.mockResolvedValue(profile);
+    setSimComplete(1);
+
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let last: any;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.loading).toBe(false);
+    expect(last.error).toBe('');
+    expect(last.resource).not.toBeNull();
+    sub.unsubscribe();
+  });
+
+  test('null response keeps loading true; subsequent tick refetches and resolves', async () => {
+    getProfileSinceMock.mockResolvedValueOnce(null);
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let last: any;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.loading).toBe(true);
+    expect(last.resource).toBeNull();
+
+    getProfileSinceMock.mockResolvedValueOnce(
+      makeProfile({ duration: '00:10:00', segments: [{ start_offset: '00:00:00', value: 'A' }] }),
+    );
+    setSimRunning(1, '00:00:30');
+    await flushPromises();
+
+    expect(last.loading).toBe(false);
+    expect(last.resource).not.toBeNull();
+    sub.unsubscribe();
+  });
+
+  test('subsequent refetch passes the last seen start_offset as sinceOffset', async () => {
+    getProfileSinceMock.mockResolvedValueOnce(
+      makeProfile({
+        duration: '00:10:00',
+        segments: [
+          { start_offset: '00:00:00', value: 'A' },
+          { start_offset: '00:01:00', value: 'B' },
+        ],
+      }),
+    );
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    sub.store.subscribe(() => {});
+    await flushPromises();
+
+    expect(getProfileSinceMock.mock.calls[0][2]).toBe('-00:00:01');
+
+    getProfileSinceMock.mockResolvedValueOnce(
+      makeProfile({ duration: '00:10:00', segments: [{ start_offset: '00:02:00', value: 'C' }] }),
+    );
+    setSimRunning(1, '00:02:00');
+    await flushPromises();
+
+    expect(getProfileSinceMock.mock.calls[1][2]).toBe('00:01:00');
+    sub.unsubscribe();
+  });
+
+  test('sim flips terminal: closing value swaps from lastOffset to header.duration', async () => {
+    getProfileSinceMock.mockResolvedValueOnce(
+      makeProfile({ duration: '00:10:00', segments: [{ start_offset: '00:01:00', value: 'A' }] }),
+    );
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let last: any;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    const startMs = new Date('2024-01-01T00:00:00').getTime();
+    let values = (last.resource as Resource).values;
+    // Streaming: closing at last segment offset (1m).
+    expect(values[values.length - 1].x).toBe(startMs + 60000);
+
+    getProfileSinceMock.mockResolvedValueOnce(makeProfile({ duration: '00:10:00', segments: [] }));
+    setSimComplete(1);
+    await flushPromises();
+
+    values = (last.resource as Resource).values;
+    // Terminal: closing at header.duration (10m).
+    expect(values[values.length - 1].x).toBe(startMs + 600000);
+    sub.unsubscribe();
+  });
+
+  // Regression: terminal sim + null profile must clear loading (no ticks
+  // will fire to retry).
+  test('terminal sim with null profile resolves loading instead of getting stuck', async () => {
+    getProfileSinceMock.mockResolvedValue(null);
+    setSimComplete(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let last: any;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.loading).toBe(false);
+    expect(last.error).toBe('');
+    expect(last.resource).toBeNull();
+  });
+
+  test('refetch error surfaces in state', async () => {
+    getProfileSinceMock.mockRejectedValue(new Error('boom'));
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let last: any;
+    sub.store.subscribe(s => {
+      last = s;
+    });
+    await flushPromises();
+
+    expect(last.error).toBe('boom');
+    expect(last.loading).toBe(false);
+    sub.unsubscribe();
+  });
+
+  test('refetch error propagates to the global timelineResourcesErroring registry', async () => {
+    const { timelineResourcesErroring } = await import('./timelineResourceStatus');
+    getProfileSinceMock.mockRejectedValue(new Error('boom'));
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+    let lastErrors: any[] = [];
+    const unsub = timelineResourcesErroring.subscribe(errs => {
+      lastErrors = errs;
+    });
+    await flushPromises();
+
+    expect(lastErrors).toHaveLength(1);
+    expect(lastErrors[0]).toMatchObject({ datasetId: 1, error: 'boom', name: 'r' });
+    unsub();
+    sub.unsubscribe();
+  });
+
+  test('dispose during in-flight refetch: no state mutations after unsubscribe', async () => {
+    let resolveFetch: (v: Profile | null) => void = () => {};
+    getProfileSinceMock.mockReturnValue(new Promise<Profile | null>(r => (resolveFetch = r)));
+    setSimRunning(1);
+    const sub = makeSub(1, 'r', '2024-01-01T00:00:00', null);
+
+    let updates = 0;
+    sub.store.subscribe(() => {
+      updates++;
+    });
+    const baseline = updates;
+
+    sub.unsubscribe();
+    resolveFetch(makeProfile({ duration: '00:10:00', segments: [{ start_offset: '00:00:00', value: 'A' }] }));
+    await flushPromises();
+
+    expect(updates).toBe(baseline);
+  });
+});
diff --git a/src/stores/profile.ts b/src/stores/profile.ts
new file mode 100644
index 0000000000..f792ec47de
--- /dev/null
+++ b/src/stores/profile.ts
@@ -0,0 +1,215 @@
+import { writable, type Readable } from 'svelte/store';
+import { Status } from '../enums/status';
+import type { User } from '../types/app';
+import type { Profile, ProfileSegment, Resource } from '../types/simulation';
+import effects from '../utilities/effects';
+import { pickEffectiveDuration } from '../utilities/profile';
+import { sampleProfiles } from '../utilities/resources';
+import { getSimulationExtent, getSimulationStatus } from '../utilities/simulation';
+import { pluralize } from '../utilities/text';
+import { logMessage } from './errors';
+import { simulationDataset } from './simulation';
+import {
+  acquireTimelineResource,
+  releaseTimelineResource,
+  setTimelineResourceState,
+  type TimelineResourceState,
+} from './timelineResourceStatus';
+
+export type ProfileSubscriptionState = TimelineResourceState;
+
+export type ProfileSubscription = {
+  store: Readable<ProfileSubscriptionState>;
+  unsubscribe: () => void;
+};
+
+type ProfileHeader = Pick<Profile, 'dataset_id' | 'duration' | 'id' | 'name' | 'type'>;
+
+// First-fetch sentinel: smaller than any real start_offset, so the windowed
+// query returns every existing segment. Postgres interval syntax (HH:MM:SS) —
+// Hasura's interval scalar rejects ISO 8601.
+const INITIAL_SINCE = '-00:00:01';
+
+/**
+ * Per-(datasetId, name) live view of a simulation resource. Driven by a
+ * windowed pull: each tick of `simulationDataset` (Hasura live query, ~1Hz)
+ * fires a refetch via GET_PROFILE_SINCE that returns only segments past the
+ * last seen `start_offset`. Same bandwidth profile as a streaming
+ * subscription, but without WS connection state, cursor reconnect handling,
+ * dedup, or a multi-phase state machine — every refetch is independent and
+ * returns the header alongside the segment delta.
+ */
+export function createProfileSubscription(
+  datasetId: number,
+  name: string,
+  planStartTimeYmd: string,
+  user: User | null,
+): ProfileSubscription {
+  const initialState: ProfileSubscriptionState = { error: '', loading: true, resource: null };
+  acquireTimelineResource(datasetId, name);
+  setTimelineResourceState(datasetId, name, 'sim', initialState);
+  const state = writable<ProfileSubscriptionState>(initialState);
+  function setState(next: ProfileSubscriptionState) {
+    state.set(next);
+    setTimelineResourceState(datasetId, name, 'sim', next);
+  }
+
+  const accumulator: ProfileSegment[] = [];
+  let header: ProfileHeader | null = null;
+  let sinceOffset = INITIAL_SINCE;
+  // Settled on a final state. Set when we receive a profile, OR when the sim
+  // goes terminal with no profile row — in that case there's no data but no
+  // more ticks will fire to retry, so we stop showing loading.
+  let resolved = false;
+  let lastError = '';
+  // Drives whether sampleProfiles closes the last segment at header.duration
+  // (terminal sim) or the last-seen offset (streaming, so header.duration
+  // would project past actual data).
+  let streamingActive = false;
+  let inFlight = false;
+  // simulationDataset re-pushes on every column change; only extent
+  // advancement implies new segments worth refetching.
+  let lastExtent: string | null = null;
+  // Set when refetch() is called while an earlier one is in flight. The
+  // finally block re-fires once, so if the sim's terminal tick lands while
+  // a refetch is mid-flight we don't miss the tail.
+  let pendingRefetch = false;
+  let disposed = false;
+  const abortController = new AbortController();
+  const unsubscribers: Array<() => void> = [];
+
+  // One log per sub lifetime, on whichever comes first: sim flipping
+  // terminal, or sub disposal. Skipped if the sub never received data.
+  const createdAt = performance.now();
+  let aggregateLogged = false;
+
+  function logFinalAggregate() {
+    if (aggregateLogged || header === null) {
+      return;
+    }
+    aggregateLogged = true;
+    logMessage(
+      `Retrieved profile "${name}" (${accumulator.length} segment${pluralize(accumulator.length)}) for dataset ID=${datasetId}.`,
+      '',
+      performance.now() - createdAt,
+    );
+  }
+
+  function emit() {
+    if (disposed) {
+      return;
+    }
+    let resource: Resource | null = null;
+    if (header && resolved) {
+      const lastOffset = accumulator.length > 0 ? accumulator[accumulator.length - 1].start_offset : null;
+      const duration = pickEffectiveDuration(header.duration, lastOffset, streamingActive);
+      resource = sampleProfiles([{ ...header, duration, profile_segments: accumulator }], planStartTimeYmd)[0] ?? null;
+    }
+    setState({ error: lastError, loading: !resolved && !lastError, resource });
+  }
+
+  async function refetch() {
+    if (disposed) {
+      return;
+    }
+    if (inFlight) {
+      pendingRefetch = true;
+      return;
+    }
+    inFlight = true;
+    try {
+      const profile = await effects.getProfileSince(datasetId, name, sinceOffset, user, abortController.signal);
+      if (disposed) {
+        return;
+      }
+      if (profile) {
+        if (profile.profile_segments.length > 0) {
+          accumulator.push(...profile.profile_segments);
+          sinceOffset = profile.profile_segments[profile.profile_segments.length - 1].start_offset;
+        }
+        header = profile;
+        resolved = true;
+        lastError = '';
+      } else if (!streamingActive) {
+        // No profile row + sim is terminal: settle so loading state clears.
+        // No more ticks will fire to retry.
+        resolved = true;
+        lastError = '';
+      }
+      if (!streamingActive) {
+        logFinalAggregate();
+      }
+      emit();
+    } catch (e) {
+      if (disposed) {
+        return;
+      }
+      const err = e as Error;
+      if (err.name === 'AbortError') {
+        return;
+      }
+      lastError = err.message || 'Profile fetch failed';
+      emit();
+    } finally {
+      inFlight = false;
+      if (pendingRefetch && !disposed) {
+        pendingRefetch = false;
+        refetch();
+      }
+    }
+  }
+
+  unsubscribers.push(
+    simulationDataset.subscribe($sd => {
+      if (disposed) {
+        return;
+      }
+      const matched = $sd !== null && $sd.dataset_id === datasetId;
+      const status = matched ? getSimulationStatus($sd) : null;
+      const next =
+        matched &&
+        status !== null &&
+        status !== Status.Complete &&
+        status !== Status.Failed &&
+        status !== Status.Canceled;
+      const streamingChanged = next !== streamingActive;
+      streamingActive = next;
+      if (matched) {
+        const extent = $sd ? getSimulationExtent($sd) : null;
+        const extentAdvanced = extent !== lastExtent;
+        lastExtent = extent;
+        // Extent moved → new segments available. streamingActive flipped →
+        // grab the tail (extent doesn't tick again on the terminal status).
+        if (extentAdvanced || streamingChanged) {
+          refetch();
+        }
+      } else if (streamingChanged && resolved) {
+        // Re-emit so the closing value picks up the new streamingActive.
+        emit();
+      }
+    }),
+  );
+
+  // Don't wait for the next simulationDataset tick — it may not come (the
+  // dataset may already be settled, null, or pointing at a different sim).
+  // Skip if `simulationDataset.subscribe` (above) already fired a refetch
+  // synchronously with its current value — otherwise we'd queue a redundant
+  // pendingRefetch and round-trip twice on first mount.
+  if (!inFlight) {
+    refetch();
+  }
+
+  return {
+    store: { subscribe: state.subscribe },
+    unsubscribe: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      logFinalAggregate();
+      releaseTimelineResource(datasetId, name);
+      abortController.abort();
+      unsubscribers.forEach(unsub => unsub());
+    },
+  };
+}
diff --git a/src/stores/simulation.ts b/src/stores/simulation.ts
index f10769b403..66defca1d2 100644
--- a/src/stores/simulation.ts
+++ b/src/stores/simulation.ts
@@ -2,7 +2,6 @@ import { keyBy } from 'lodash-es';
 import { derived, writable, type Readable, type Writable } from 'svelte/store';
 import { Status } from '../enums/status';
 import type {
-  Resource,
   ResourceType,
   Simulation,
   SimulationDataset,
@@ -18,20 +17,15 @@ import type { Axis } from '../types/timeline';
 import { createSpanUtilityMaps } from '../utilities/activities';
 import gql from '../utilities/gql';
 import { getSimulationProgress } from '../utilities/simulation';
-import { planId, planModelId, planModelRevision, planRevision } from './plan';
+import { planDatasets, planId, planModelId, planModelRevision, planRevision } from './plan';
 import { gqlSubscribable } from './subscribable';
 
 /* Writeable. */
 
 export const simulationDatasetId: Writable<number> = writable(-1);
 
-export const externalResources: Writable<Resource[]> = writable([]);
-
 export const externalResourceNames: Writable<string[]> = writable([]);
 
-// default to true since we cannot differentiate between "ext resources have been initially fetched" and "fetching ext resources"
-export const fetchingResourcesExternal: Writable<boolean> = writable(true);
-
 export const resourceTypes: Writable<ResourceType[]> = writable([]);
 
 export const resourceTypesLoading: Writable<boolean> = writable(true);
@@ -97,11 +91,32 @@ export const selectedSimulationEventId: Writable<number | null> = writable(null)
 /* Derived. */
 
 export const allResourceTypes: Readable<ResourceType[]> = derived(
-  [resourceTypes, externalResources],
-  ([$resourceTypes, $externalResources]) => {
-    return $resourceTypes
-      .map(({ name, schema }) => ({ name, schema }))
-      .concat($externalResources.map(({ name, schema }) => ({ name, schema })));
+  [resourceTypes, planDatasets, simulationDatasetId],
+  ([$resourceTypes, $planDatasets, $simulationDatasetId]) => {
+    const seen = new Set<string>();
+    const out: ResourceType[] = [];
+    // Add resource types from the model
+    for (const { name, schema } of $resourceTypes) {
+      if (!seen.has(name)) {
+        seen.add(name);
+        out.push({ name, schema });
+      }
+    }
+    // Add resource types from datasets tied to the current sim or untied to any sim (plan-level).
+    for (const planDataset of $planDatasets) {
+      const tiedToOtherSim =
+        planDataset.simulation_dataset_id !== null && planDataset.simulation_dataset_id !== $simulationDatasetId;
+      if (tiedToOtherSim) {
+        continue;
+      }
+      for (const profile of planDataset.dataset.profiles) {
+        if (!seen.has(profile.name)) {
+          seen.add(profile.name);
+          out.push({ name: profile.name, schema: profile.type.schema });
+        }
+      }
+    }
+    return out;
   },
 );
 
@@ -171,9 +186,7 @@ export const simulationDatasetLatestId = derived(
 /* Helper Functions. */
 
 export function resetSimulationStores() {
-  externalResources.set([]);
   externalResourceNames.set([]);
-  fetchingResourcesExternal.set(false);
   initialSpansLoading.set(true);
   selectedSpanId.update(() => null);
   simulation.updateValue(() => null);
diff --git a/src/stores/timelineResourceStatus.ts b/src/stores/timelineResourceStatus.ts
new file mode 100644
index 0000000000..cf1b4acc73
--- /dev/null
+++ b/src/stores/timelineResourceStatus.ts
@@ -0,0 +1,99 @@
+import { derived, writable, type Readable } from 'svelte/store';
+import type { Resource } from '../types/simulation';
+
+// Per-(datasetId, name) loading/error registry for any resource on the
+// timeline. Two writers — `createProfileSubscription` (sim profiles) and
+// `createExternalResourceSubscription` (external datasets) — share the same
+// keyspace; the global indicator reads the derived aggregates. `kind`
+// travels with each entry so the indicator can label errors with the right
+// source ("Profile" vs "External profile") instead of mixing them.
+
+export type TimelineResourceKind = 'sim' | 'external';
+
+export type TimelineResourceState = {
+  error: string;
+  loading: boolean;
+  resource: Resource | null;
+};
+
+export type TimelineResourceError = {
+  datasetId: number;
+  error: string;
+  kind: TimelineResourceKind;
+  name: string;
+};
+
+type StoredState = TimelineResourceState & { kind: TimelineResourceKind };
+
+const resourceStates = writable<Map<string, StoredState>>(new Map());
+
+// Refcount per key. Two Row.svelte instances showing the same
+// (datasetId, name) each create their own factory writing to this key.
+// Without refcounting, the first to dispose clears the entry while the
+// other factory is still live — and for a settled-error state (e.g.
+// external "Resource not found"), nothing would trigger a re-emit, so the
+// indicator would silently under-report. Acquire/release scopes the entry
+// to the union of writers' lifetimes.
+const refCounts = new Map<string, number>();
+
+export const timelineResourcesLoading: Readable<boolean> = derived(resourceStates, $resourceStates => {
+  for (const s of $resourceStates.values()) {
+    if (s.loading) {
+      return true;
+    }
+  }
+  return false;
+});
+
+export const timelineResourcesErroring: Readable<TimelineResourceError[]> = derived(resourceStates, $resourceStates => {
+  const errors: TimelineResourceError[] = [];
+  for (const [key, s] of $resourceStates.entries()) {
+    if (s.error) {
+      const colon = key.indexOf(':');
+      errors.push({
+        datasetId: Number(key.slice(0, colon)),
+        error: s.error,
+        kind: s.kind,
+        name: key.slice(colon + 1),
+      });
+    }
+  }
+  return errors;
+});
+
+function registryKey(datasetId: number, name: string): string {
+  return `${datasetId}:${name}`;
+}
+
+export function acquireTimelineResource(datasetId: number, name: string): void {
+  const key = registryKey(datasetId, name);
+  refCounts.set(key, (refCounts.get(key) ?? 0) + 1);
+}
+
+export function setTimelineResourceState(
+  datasetId: number,
+  name: string,
+  kind: TimelineResourceKind,
+  state: TimelineResourceState,
+): void {
+  const key = registryKey(datasetId, name);
+  resourceStates.update(m => new Map(m).set(key, { ...state, kind }));
+}
+
+export function releaseTimelineResource(datasetId: number, name: string): void {
+  const key = registryKey(datasetId, name);
+  const next = (refCounts.get(key) ?? 1) - 1;
+  if (next <= 0) {
+    refCounts.delete(key);
+    resourceStates.update(m => {
+      if (!m.has(key)) {
+        return m;
+      }
+      const after = new Map(m);
+      after.delete(key);
+      return after;
+    });
+  } else {
+    refCounts.set(key, next);
+  }
+}
diff --git a/src/types/simulation.ts b/src/types/simulation.ts
index d559032bff..ec8450e39a 100644
--- a/src/types/simulation.ts
+++ b/src/types/simulation.ts
@@ -3,12 +3,12 @@ import type { UserId } from './app';
 import type { BaseError, SimulationDatasetError } from './errors';
 import type { ArgumentsMap } from './parameter';
 import type { ValueSchema } from './schema';
-import type { Subscription } from './subscribable';
 
 export type PlanDataset = {
   dataset: { profiles: Profile[] };
   dataset_id: number;
   offset_from_plan_start: string;
+  simulation_dataset_id: number | null;
 };
 
 export type PlanDatasetNames = {
@@ -45,13 +45,12 @@ export type Resource = {
 };
 
 export type ResourceRequest = {
-  controller?: AbortController;
   error: string;
   loading: boolean;
   resource: Resource | null;
   simulationDatasetId: number;
-  subscription?: Subscription<Resource>;
   type: 'internal' | 'external';
+  unsubscribe?: () => void;
 };
 
 export type ResourceType = {
diff --git a/src/utilities/effects.ts b/src/utilities/effects.ts
index 879bb63059..3ef0cd949e 100644
--- a/src/utilities/effects.ts
+++ b/src/utilities/effects.ts
@@ -213,9 +213,8 @@ import {
   type SequenceAdaptationMetadata,
 } from '../types/sequencing';
 import type {
-  PlanDataset,
   Profile,
-  Resource,
+  ProfileSegment,
   ResourceType,
   SimulateResponse,
   Simulation,
@@ -259,7 +258,7 @@ import {
   packActivityDirectivesInPlan,
 } from './activities';
 import { ErrorTypes } from './errors';
-import { compare, convertToQuery } from './generic';
+import { convertToQuery } from './generic';
 import gql, { convertToGQLArray } from './gql';
 import {
   showApplySequenceFilterModal,
@@ -297,7 +296,6 @@ import {
 } from './modal';
 import { featurePermissions, gatewayPermissions, queryPermissions } from './permissions';
 import { CompoundError, reqActionServer, reqExtension, reqGateway, reqHasura } from './requests';
-import { sampleProfiles } from './resources';
 import { convertResponseToMetadata } from './scheduling';
 import { compareEvents } from './simulation';
 import { pluralize } from './text';
@@ -4748,6 +4746,38 @@ const effects = {
     }
   },
 
+  async getExternalProfileSegmentsSince(
+    datasetId: number,
+    profileId: number,
+    sinceOffset: string,
+    user: User | null,
+    signal: AbortSignal | undefined = undefined,
+  ): Promise<ProfileSegment[] | null> {
+    try {
+      const data = await reqHasura<{ profile_segments: ProfileSegment[] }[]>(
+        gql.GET_EXTERNAL_PROFILE_SEGMENTS_SINCE,
+        { datasetId, profileId, sinceOffset },
+        user,
+        signal,
+      );
+      const { profile: profiles } = data;
+      if (profiles && profiles.length === 1) {
+        return profiles[0].profile_segments;
+      }
+      return null;
+    } catch (e) {
+      const error = e as Error;
+      if (error.name === 'AbortError') {
+        throw error;
+      }
+      catchError(
+        `Failed to retrieve external profile segments (datasetId=${datasetId}, profileId=${profileId})`,
+        error,
+      );
+      throw error;
+    }
+  },
+
   async getFile(
     fileId: number,
     user: User | null,
@@ -5125,14 +5155,30 @@ const effects = {
     }
   },
 
-  getResource(
+  async getProfileSince(
     datasetId: number,
     name: string,
+    sinceOffset: string,
     user: User | null,
     signal: AbortSignal | undefined = undefined,
-  ): Promise<Record<string, Profile[] | null>> {
-    const data = reqHasura<Profile[]>(gql.GET_PROFILE, { datasetId, name }, user, signal);
-    return data;
+  ): Promise<Profile | null> {
+    try {
+      const data = await reqHasura<Profile[]>(gql.GET_PROFILE_SINCE, { datasetId, name, sinceOffset }, user, signal);
+      const { profile: profiles } = data;
+      if (profiles && profiles.length === 1) {
+        return profiles[0];
+      }
+      return null;
+    } catch (e) {
+      const error = e as Error;
+      if (error.name === 'AbortError') {
+        throw error;
+      }
+      // Re-throw so the caller can surface the error in the timeline status
+      // indicator; catchError still routes it to the global log pipeline.
+      catchError(`Unable to retrieve profile ${name}`, error);
+      throw error;
+    }
   },
 
   async getResourceTypes(modelId: number, user: User | null, limit: number | null = null): Promise<ResourceType[]> {
@@ -5156,78 +5202,6 @@ const effects = {
     }
   },
 
-  async getResourcesExternal(
-    planId: number,
-    simulationDatasetId: number | null,
-    startTimeYmd: string,
-    user: User | null,
-    signal: AbortSignal | undefined = undefined,
-  ): Promise<{ aborted: boolean; resources: Resource[] }> {
-    try {
-      // Always fetch external resources that aren't tied to a simulation, optionally get the resources tied to one if we have a dataset ID.
-      const clauses: { simulation_dataset_id: { _is_null: boolean } | { _eq: number } }[] = [
-        { simulation_dataset_id: { _is_null: true } },
-      ];
-      if (simulationDatasetId !== null) {
-        clauses.push({ simulation_dataset_id: { _eq: simulationDatasetId } });
-      }
-
-      const data = await reqHasura<PlanDataset[]>(
-        gql.GET_PROFILES_EXTERNAL,
-        {
-          planId,
-          simulationDatasetFilter: clauses,
-        },
-        user,
-        signal,
-      );
-      const { plan_dataset: planDatasets } = data;
-      if (planDatasets != null) {
-        let resources: Resource[] = [];
-
-        const profileMap: Set<string> = new Set();
-        planDatasets.sort(({ dataset_id: datasetIdA }, { dataset_id: datasetIdB }) => {
-          return compare(datasetIdA, datasetIdB, false);
-        });
-
-        for (const dataset of planDatasets) {
-          const {
-            dataset: { profiles },
-            offset_from_plan_start,
-          } = dataset;
-          const uniqueProfiles: Profile[] = profiles.filter(profile => {
-            if (!profileMap.has(profile.name)) {
-              profileMap.add(profile.name);
-              return true;
-            }
-            return false;
-          });
-
-          uniqueProfiles.forEach(profile => {
-            logMessage(
-              `Retrieved external profile ${profile.name} (${profile.profile_segments} segment${profile.profile_segments.length}) for simulation ID=${simulationDatasetId}.`,
-            );
-          });
-
-          const sampledResources: Resource[] = sampleProfiles(uniqueProfiles, startTimeYmd, offset_from_plan_start);
-          resources = [...resources, ...sampledResources];
-        }
-        return { aborted: false, resources };
-      } else {
-        throw Error('Unable to get external resources');
-      }
-    } catch (e) {
-      let aborted = false;
-      const error = e as Error;
-      if (error.name !== 'AbortError') {
-        catchError('Unable to retrieve external profiles ', error);
-        showFailureToast('Failed to retrieve external profiles');
-        aborted = true;
-      }
-      return { aborted, resources: [] };
-    }
-  },
-
   async getRolePermissions(user: User | null): Promise<RolePermissionsMap | null> {
     try {
       const roleData = await reqHasura<RolePermissionResponse[] | null>(gql.GET_ROLE_PERMISSIONS, {}, user, undefined);
diff --git a/src/utilities/gql.ts b/src/utilities/gql.ts
index 1621776dad..3eb2d23190 100644
--- a/src/utilities/gql.ts
+++ b/src/utilities/gql.ts
@@ -1392,6 +1392,28 @@ const gql = {
     }
   `,
 
+  // Windowed pull for an external profile's segments — counterpart to
+  // GET_PROFILE_SINCE for sim profiles. Keyed on (datasetId, profileId)
+  // because external names can collide across plan_dataset rows (e.g. one
+  // tied to a sim, one plan-level); planDatasets metadata is responsible
+  // for picking which row, then this query fetches that row's deltas.
+  GET_EXTERNAL_PROFILE_SEGMENTS_SINCE: `#graphql
+    query GetExternalProfileSegmentsSince($datasetId: Int!, $profileId: Int!, $sinceOffset: interval!) {
+      ${Queries.PROFILES}(where: { _and: { dataset_id: { _eq: $datasetId }, id: { _eq: $profileId } } }, limit: 1) {
+        profile_segments(
+          where: { _and: { dataset_id: { _eq: $datasetId }, start_offset: { _gt: $sinceOffset } } }
+          order_by: { start_offset: asc }
+        ) {
+          dataset_id
+          dynamics
+          is_gap
+          profile_id
+          start_offset
+        }
+      }
+    }
+  `,
+
   GET_MODELS: `#graphql
     query GetModels {
       models: ${Queries.MISSION_MODELS} {
@@ -1684,14 +1706,20 @@ const gql = {
     }
   `,
 
-  GET_PROFILE: `#graphql
-    query GetProfile($datasetId: Int!, $name: String!) {
+  // Windowed pull: returns the profile header + only the segments past
+  // sinceOffset. Pass "-00:00:01" on the first call to get everything; pass
+  // the last seen start_offset on subsequent calls to get only the delta.
+  GET_PROFILE_SINCE: `#graphql
+    query GetProfileSince($datasetId: Int!, $name: String!, $sinceOffset: interval!) {
       ${Queries.PROFILES}(where: { _and: { dataset_id: { _eq: $datasetId }, name: { _eq: $name } } }, limit: 1) {
         dataset_id
         duration
         id
         name
-        profile_segments(where: { dataset_id: { _eq: $datasetId } }, order_by: { start_offset: asc }) {
+        profile_segments(
+          where: { _and: { dataset_id: { _eq: $datasetId }, start_offset: { _gt: $sinceOffset } } }
+          order_by: { start_offset: asc }
+        ) {
           dataset_id
           dynamics
           is_gap
@@ -1703,31 +1731,6 @@ const gql = {
     }
   `,
 
-  GET_PROFILES_EXTERNAL: `#graphql
-    query GetProfilesExternal($planId: Int!, $simulationDatasetFilter: [plan_dataset_bool_exp!]) {
-      ${Queries.PLAN_DATASETS}(where: { plan_id: { _eq: $planId }, _or: $simulationDatasetFilter }) {
-        dataset {
-          profiles {
-            dataset_id
-            duration
-            id
-            name
-            profile_segments(order_by: { start_offset: asc }) {
-              dataset_id
-              dynamics
-              is_gap
-              profile_id
-              start_offset
-            }
-            type
-          }
-        }
-        dataset_id
-        offset_from_plan_start
-      }
-    }
-  `,
-
   GET_RESOURCE_TYPES: `#graphql
     query GetResourceTypes($model_id: Int!, $limit: Int) {
       resource_types: ${Queries.RESOURCE_TYPES}(where: { model_id: { _eq: $model_id } }, order_by: { name: asc }, limit: $limit) {
@@ -2896,6 +2899,7 @@ const gql = {
     subscription SubPlanDatasets($planId: Int!) {
       ${Queries.PLAN_DATASETS}(where: {plan_id: {_eq: $planId}}) {
         dataset_id
+        offset_from_plan_start
         simulation_dataset_id
         dataset {
           profiles {
diff --git a/src/utilities/permissions.ts b/src/utilities/permissions.ts
index 0e6ea43465..be5ce3e232 100644
--- a/src/utilities/permissions.ts
+++ b/src/utilities/permissions.ts
@@ -804,6 +804,7 @@ const queryPermissions: Record<GQLKeys, (user: User | null, ...args: any[]) => b
   GET_EXPANSION_SEQUENCE_SEQ_JSON: () => true,
   GET_EXTERNAL_EVENTS: () => true,
   GET_EXTERNAL_EVENT_TYPE_BY_SOURCE: () => true,
+  GET_EXTERNAL_PROFILE_SEGMENTS_SINCE: () => true,
   GET_MODELS: () => true,
   GET_PARCEL: () => true,
   GET_PARSED_CHANNEL_DICTIONARY: () => true,
@@ -821,8 +822,7 @@ const queryPermissions: Record<GQLKeys, (user: User | null, ...args: any[]) => b
   GET_PLAN_SNAPSHOT_ACTIVITY_DIRECTIVES: (user: User | null): boolean => {
     return isUserAdmin(user) || getPermission([Queries.PLAN_SNAPSHOT_ACTIVITIES], user);
   },
-  GET_PROFILE: () => true,
-  GET_PROFILES_EXTERNAL: () => true,
+  GET_PROFILE_SINCE: () => true,
   GET_RESOURCE_TYPES: () => true,
   GET_ROLE_PERMISSIONS: () => true,
   GET_SCHEDULING_PROCEDURE_EFFECTIVE_ARGUMENTS_BULK: () => true,
diff --git a/src/utilities/profile.test.ts b/src/utilities/profile.test.ts
new file mode 100644
index 0000000000..053d97e5c7
--- /dev/null
+++ b/src/utilities/profile.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, test } from 'vitest';
+import { pickEffectiveDuration } from './profile';
+
+describe('pickEffectiveDuration', () => {
+  test('returns headerDuration when there are no segments yet', () => {
+    expect(pickEffectiveDuration('00:10:00', null, true)).toBe('00:10:00');
+    expect(pickEffectiveDuration('00:10:00', null, false)).toBe('00:10:00');
+  });
+
+  test('while streaming, returns the last segment offset (no extrapolation)', () => {
+    // header.duration may be plan duration upfront or running extent — both
+    // would extend past actually-received data. We terminate at last offset.
+    expect(pickEffectiveDuration('05:00:00', '00:01:00', true)).toBe('00:01:00');
+  });
+
+  test('once streaming stops, returns headerDuration when it is >= lastOffset', () => {
+    expect(pickEffectiveDuration('00:10:00', '00:01:00', false)).toBe('00:10:00');
+  });
+
+  test('once streaming stops, falls back to lastOffset when headerDuration is shorter', () => {
+    // Defensive: if backend somehow has a stale/short duration but we have
+    // a segment at a later offset, the segment offset wins so the values
+    // array stays sorted.
+    expect(pickEffectiveDuration('00:00:30', '00:01:00', false)).toBe('00:01:00');
+  });
+});
diff --git a/src/utilities/profile.ts b/src/utilities/profile.ts
new file mode 100644
index 0000000000..57c161234f
--- /dev/null
+++ b/src/utilities/profile.ts
@@ -0,0 +1,31 @@
+import { getIntervalInMs } from './time';
+
+/**
+ * Picks the duration sampleProfiles uses to place the closing value of the
+ * final segment. While streaming, the last received segment is the data
+ * frontier. Once terminal, header.duration wins — unless a stale/short
+ * header would land before the last received segment offset, in which case
+ * we fall back to the offset to keep values sorted.
+ */
+export function pickEffectiveDuration(
+  headerDuration: string,
+  lastSegmentStartOffset: string | null,
+  streamingActive: boolean,
+): string {
+  if (lastSegmentStartOffset === null) {
+    return headerDuration;
+  }
+  if (streamingActive) {
+    return lastSegmentStartOffset;
+  }
+  // Defend against malformed input: getIntervalInMs returns 0 for unparseable
+  // strings, which would silently pick a too-short header and produce an
+  // unsorted values array (pinned by sort-invariant regression test in
+  // resources.test.ts).
+  const headerMs = getIntervalInMs(headerDuration);
+  const offsetMs = getIntervalInMs(lastSegmentStartOffset);
+  if (!Number.isFinite(headerMs) || !Number.isFinite(offsetMs)) {
+    return lastSegmentStartOffset;
+  }
+  return headerMs >= offsetMs ? headerDuration : lastSegmentStartOffset;
+}
diff --git a/src/utilities/resources.test.ts b/src/utilities/resources.test.ts
index 1b63d22590..8c28dd97ff 100644
--- a/src/utilities/resources.test.ts
+++ b/src/utilities/resources.test.ts
@@ -1,7 +1,39 @@
 import { describe, expect, test } from 'vitest';
-import type { Profile, Resource } from '../types/simulation';
+import type { Profile, ProfileSegment, Resource } from '../types/simulation';
 import { sampleProfiles } from './resources';
 
+const START = '2024-01-01T00:00:00';
+const startMs = new Date(START).getTime();
+
+type DiscreteSeg = { is_gap?: boolean; start_offset: string; value: any };
+type RealSeg = { initial: number; is_gap?: boolean; rate: number; start_offset: string };
+
+function makeSegment(start_offset: string, dynamics: any, is_gap = false): ProfileSegment {
+  return { dataset_id: 1, dynamics, is_gap, profile_id: 1, start_offset };
+}
+
+function discreteProfile(duration: string, segments: DiscreteSeg[]): Profile {
+  return {
+    dataset_id: 1,
+    duration,
+    id: 1,
+    name: 'r',
+    profile_segments: segments.map(s => makeSegment(s.start_offset, s.value, s.is_gap)),
+    type: { schema: { type: 'string' } as any, type: 'discrete' },
+  };
+}
+
+function realProfile(duration: string, segments: RealSeg[]): Profile {
+  return {
+    dataset_id: 1,
+    duration,
+    id: 1,
+    name: 'r',
+    profile_segments: segments.map(s => makeSegment(s.start_offset, { initial: s.initial, rate: s.rate }, s.is_gap)),
+    type: { schema: { type: 'real' } as any, type: 'real' },
+  };
+}
+
 describe('sampleProfiles', () => {
   test('Calculate the correct y-value for real profile segment rate of change', () => {
     const profiles: Profile[] = [
@@ -110,4 +142,129 @@ describe('sampleProfiles', () => {
 
     expect(resources).toEqual(expectedResources);
   });
+
+  test('returns [] when profiles is null', () => {
+    expect(sampleProfiles(null, START)).toEqual([]);
+  });
+
+  test('returns [] when startTimeYmd is null', () => {
+    expect(sampleProfiles([discreteProfile('00:01:00', [])], null)).toEqual([]);
+  });
+
+  test('returns one resource with empty values for a profile with no segments', () => {
+    const result = sampleProfiles([discreteProfile('00:01:00', [])], START);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toEqual('r');
+    expect(result[0].values).toEqual([]);
+  });
+
+  describe('discrete profile', () => {
+    test('produces two values per segment using the next segment start as second x', () => {
+      const profile = discreteProfile('00:01:00', [
+        { start_offset: '00:00:00', value: 'A' },
+        { start_offset: '00:00:30', value: 'B' },
+      ]);
+      const [resource] = sampleProfiles([profile], START);
+      expect(resource.values).toEqual([
+        { is_gap: false, x: startMs + 0, y: 'A' },
+        { is_gap: false, x: startMs + 30000, y: 'A' },
+        { is_gap: false, x: startMs + 30000, y: 'B' },
+        { is_gap: false, x: startMs + 60000, y: 'B' },
+      ]);
+    });
+
+    test('uses durationMs for the closing x of the last segment', () => {
+      const profile = discreteProfile('00:02:00', [{ start_offset: '00:00:30', value: 'A' }]);
+      const [resource] = sampleProfiles([profile], START);
+      expect(resource.values).toEqual([
+        { is_gap: false, x: startMs + 30000, y: 'A' },
+        { is_gap: false, x: startMs + 120000, y: 'A' },
+      ]);
+    });
+
+    test('propagates is_gap to both values produced by a gap segment', () => {
+      const profile = discreteProfile('00:01:00', [{ is_gap: true, start_offset: '00:00:00', value: 'X' }]);
+      const [resource] = sampleProfiles([profile], START);
+      expect(resource.values.every(v => v.is_gap === true)).toBe(true);
+    });
+  });
+
+  describe('real profile', () => {
+    test('uses dynamics.initial as the segment-start y value', () => {
+      const profile = realProfile('00:01:00', [{ initial: 50, rate: 0, start_offset: '00:00:00' }]);
+      const [resource] = sampleProfiles([profile], START);
+      expect(resource.values[0]).toEqual({ is_gap: false, x: startMs, y: 50 });
+    });
+
+    test('connects consecutive segments at the same x with their respective y values', () => {
+      const profile = realProfile('00:02:00', [
+        { initial: 0, rate: 0, start_offset: '00:00:00' },
+        { initial: 10, rate: 0, start_offset: '00:01:00' },
+      ]);
+      const [resource] = sampleProfiles([profile], START);
+      expect(resource.values[1].x).toEqual(resource.values[2].x);
+      expect(resource.values[1].y).toEqual(0);
+      expect(resource.values[2].y).toEqual(10);
+    });
+  });
+
+  describe('sort invariants', () => {
+    test('values are sorted ASC by x when duration >= max segment start_offset', () => {
+      const profile = discreteProfile('00:05:00', [
+        { start_offset: '00:00:00', value: 'A' },
+        { start_offset: '00:01:00', value: 'B' },
+        { start_offset: '00:02:00', value: 'C' },
+        { start_offset: '00:03:00', value: 'D' },
+      ]);
+      const [resource] = sampleProfiles([profile], START);
+      const xs = resource.values.map(v => v.x);
+      expect(xs).toEqual([...xs].sort((a, b) => a - b));
+    });
+
+    // Pin: if duration < last segment offset, the closing value lands before
+    // its own open x and decimation breaks. profile.ts guards this via
+    // pickEffectiveDuration; this test catches a "be lenient" regression.
+    test('garbage-in: values are NOT sorted when duration < last segment start_offset', () => {
+      const profile = discreteProfile('00:00:00', [
+        { start_offset: '00:00:00', value: 'A' },
+        { start_offset: '00:01:00', value: 'B' },
+      ]);
+      const [resource] = sampleProfiles([profile], START);
+      const xs = resource.values.map(v => v.x);
+      const sorted = [...xs].sort((a, b) => a - b);
+      expect(xs).not.toEqual(sorted);
+    });
+
+    test('produces only finite x and y for well-formed real-typed input', () => {
+      const profile = realProfile('00:10:00', [
+        { initial: 0, rate: 1, start_offset: '00:00:00' },
+        { initial: 5, rate: -1, start_offset: '00:05:00' },
+      ]);
+      const [resource] = sampleProfiles([profile], START);
+      for (const v of resource.values) {
+        expect(Number.isFinite(v.x)).toBe(true);
+        expect(typeof v.y === 'number' && Number.isFinite(v.y)).toBe(true);
+      }
+    });
+  });
+
+  test('offsetInterval shifts every x by the offset', () => {
+    const profile = discreteProfile('00:01:00', [{ start_offset: '00:00:00', value: 'A' }]);
+    const [resource] = sampleProfiles([profile], START, '00:00:10');
+    expect(resource.values).toEqual([
+      { is_gap: false, x: startMs + 10000, y: 'A' },
+      { is_gap: false, x: startMs + 70000, y: 'A' },
+    ]);
+  });
+
+  test('handles multiple profiles independently', () => {
+    const a = discreteProfile('00:01:00', [{ start_offset: '00:00:00', value: 'A' }]);
+    a.name = 'a';
+    const b = discreteProfile('00:01:00', [{ start_offset: '00:00:00', value: 'B' }]);
+    b.name = 'b';
+    const result = sampleProfiles([a, b], START);
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toEqual('a');
+    expect(result[1].name).toEqual('b');
+  });
 });