@happyvertical/smrt-svelte 0.38.1 → 0.38.3

package/dist/components/workspace/live/system-feed.svelte.d.ts

@@ -0,0 +1,129 @@
+/**
+ * `systemFeed` — a transport-light polling helper for the AdminShell system
+ * scope (issue #1774, epic #1766).
+ *
+ * The System edge presents jobs / schedules / dispatch — data that lives in the
+ * `_smrt_*` SYSTEM tables. Those tables are intentionally **excluded** from the
+ * core change-feed (`packages/core/src/change-feed.ts`) and are **not** surfaced
+ * as `smrt-web` collections, so the live-collection path used by tenant/app
+ * data does not apply here. Instead, an app exposes its own status endpoint
+ * (a `+server.ts` that reads `_smrt_*` through the `smrt-jobs` query API) and
+ * this helper polls it on an interval, mapping the response into the
+ * presentation contracts the shell already renders:
+ * `ShellSystemPanel[]` (for `SystemScopePanel`) and `ShellStatusChip[]`
+ * (for `SystemStatusChips`).
+ *
+ * This module is deliberately kept OUT of the `./workspace` presentation barrel
+ * and the `./web` (smrt-web / TanStack) entry: it is opt-in via the
+ * `@happyvertical/smrt-svelte/workspace/live` subpath and pulls no runtime
+ * dependency beyond Svelte's reactivity. It only imports the shell's *types*.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { systemFeed } from '@happyvertical/smrt-svelte/workspace/live';
+ *   import { SystemScopePanel, SystemStatusChips } from
+ *     '@happyvertical/smrt-svelte/workspace';
+ *   import { onDestroy } from 'svelte';
+ *
+ *   const feed = systemFeed({
+ *     fetch: () => fetch('/admin/system/status').then((r) => r.json()),
+ *     intervalMs: 5000,
+ *     map: (status) => ({ panels: toPanels(status), chips: toChips(status) }),
+ *   });
+ *   onDestroy(feed.dispose);
+ * </script>
+ *
+ * <SystemStatusChips chips={feed.chips} />
+ * <SystemScopePanel panels={feed.panels} />
+ * ```
+ */
+import type { ShellStatusChip, ShellSystemPanel } from '../admin-shell/types.js';
+/** Lifecycle phase of a {@link SystemFeedController}. */
+export type SystemFeedStatus = 'idle' | 'loading' | 'success' | 'error' | 'stopped';
+/**
+ * The shell-facing shape produced by {@link SystemFeedOptions.map}. Either half
+ * is optional so a feed can drive only the panels, only the chips, or both.
+ */
+export interface SystemFeedView {
+    panels?: ShellSystemPanel[];
+    chips?: ShellStatusChip[];
+}
+/** Options for {@link systemFeed}. */
+export interface SystemFeedOptions<T> {
+    /**
+     * App-supplied async loader. Called on each tick (and once immediately unless
+     * `immediate` is `false`). Typically wraps `fetch('/…/status')`. Its resolved
+     * value is handed to {@link SystemFeedOptions.map}. Rejections are caught and
+     * surfaced via `error` / `onError` without stopping the poll loop.
+     */
+    fetch: (signal: AbortSignal) => T | Promise<T>;
+    /**
+     * Maps a raw `fetch` result into the shell presentation contracts. Runs
+     * inside the same try/catch as `fetch`, so a throwing mapper is treated as a
+     * failed tick (tolerated, loop continues).
+     */
+    map: (data: T) => SystemFeedView;
+    /**
+     * Poll interval in milliseconds. Values `<= 0` disable the timer (single
+     * fetch only, useful for tests / manual `refresh()`). Default `5000`.
+     */
+    intervalMs?: number;
+    /**
+     * Fetch once as soon as the feed is created. Default `true`. When `false`,
+     * nothing is fetched until the first timer tick or an explicit `refresh()`.
+     */
+    immediate?: boolean;
+    /**
+     * Skip ticks while `document.hidden` is true and refresh once on the next
+     * `visibilitychange` back to visible. Avoids polling a backgrounded tab.
+     * Default `true`. Ignored (treated as `false`) when there is no `document`
+     * (SSR / non-DOM environments).
+     */
+    pauseWhenHidden?: boolean;
+    /** Notified on every caught fetch/map error. Never throws into the loop. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Reactive controller returned by {@link systemFeed}. `panels` / `chips` are
+ * `$state`-backed getters safe to bind straight to `SystemScopePanel` /
+ * `SystemStatusChips`. Call {@link SystemFeedController.dispose} (e.g. from
+ * `onDestroy`) to stop the timer and detach listeners — this is the disposer.
+ */
+export interface SystemFeedController {
+    /** Latest mapped panels; `[]` until the first successful tick. */
+    readonly panels: ShellSystemPanel[];
+    /** Latest mapped chips; `[]` until the first successful tick. */
+    readonly chips: ShellStatusChip[];
+    /** Lifecycle phase of the most recent tick. */
+    readonly status: SystemFeedStatus;
+    /** The most recent caught error, or `null` after any success. */
+    readonly error: unknown;
+    /**
+     * Whether the poll timer is currently armed. Stays `false` for single-shot
+     * feeds (`intervalMs <= 0`), under SSR (no `document`), and after `stop()` /
+     * `dispose()`.
+     */
+    readonly running: boolean;
+    /** Fetch + map once, off-schedule. Resolves after state is updated. */
+    refresh(): Promise<void>;
+    /**
+     * (Re)arm the poll timer. Idempotent. No-op when already running, after
+     * {@link dispose}, when `intervalMs <= 0`, or under SSR (no `document`).
+     */
+    start(): void;
+    /** Disarm the poll timer without tearing down listeners. Idempotent. */
+    stop(): void;
+    /** Stop the timer, detach listeners, abort any in-flight fetch. Terminal. */
+    dispose(): void;
+}
+/**
+ * Create a polling feed that maps an app status endpoint into the AdminShell
+ * system-scope presentation contracts.
+ *
+ * The returned {@link SystemFeedController} exposes reactive `panels` / `chips`
+ * and a `dispose()` disposer. Bind the getters to the shell components and call
+ * `dispose()` on teardown.
+ */
+export declare function systemFeed<T>(options: SystemFeedOptions<T>): SystemFeedController;
+//# sourceMappingURL=system-feed.svelte.d.ts.map

package/dist/components/workspace/live/system-feed.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-feed.svelte.d.ts","sourceRoot":"","sources":["../../../../src/components/workspace/live/system-feed.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,yDAAyD;AACzD,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,CAAC;AAEd;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,sCAAsC;AACtC,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC;;;;;OAKG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/C;;;;OAIG;IACH,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,cAAc,CAAC;IACjC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IACpC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,eAAe,EAAE,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IACd,wEAAwE;IACxE,IAAI,IAAI,IAAI,CAAC;IACb,6EAA6E;IAC7E,OAAO,IAAI,IAAI,CAAC;CACjB;AAID;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC5B,oBAAoB,CA6ItB"}

package/dist/components/workspace/live/system-feed.svelte.js

@@ -0,0 +1,201 @@
+/**
+ * `systemFeed` — a transport-light polling helper for the AdminShell system
+ * scope (issue #1774, epic #1766).
+ *
+ * The System edge presents jobs / schedules / dispatch — data that lives in the
+ * `_smrt_*` SYSTEM tables. Those tables are intentionally **excluded** from the
+ * core change-feed (`packages/core/src/change-feed.ts`) and are **not** surfaced
+ * as `smrt-web` collections, so the live-collection path used by tenant/app
+ * data does not apply here. Instead, an app exposes its own status endpoint
+ * (a `+server.ts` that reads `_smrt_*` through the `smrt-jobs` query API) and
+ * this helper polls it on an interval, mapping the response into the
+ * presentation contracts the shell already renders:
+ * `ShellSystemPanel[]` (for `SystemScopePanel`) and `ShellStatusChip[]`
+ * (for `SystemStatusChips`).
+ *
+ * This module is deliberately kept OUT of the `./workspace` presentation barrel
+ * and the `./web` (smrt-web / TanStack) entry: it is opt-in via the
+ * `@happyvertical/smrt-svelte/workspace/live` subpath and pulls no runtime
+ * dependency beyond Svelte's reactivity. It only imports the shell's *types*.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { systemFeed } from '@happyvertical/smrt-svelte/workspace/live';
+ *   import { SystemScopePanel, SystemStatusChips } from
+ *     '@happyvertical/smrt-svelte/workspace';
+ *   import { onDestroy } from 'svelte';
+ *
+ *   const feed = systemFeed({
+ *     fetch: () => fetch('/admin/system/status').then((r) => r.json()),
+ *     intervalMs: 5000,
+ *     map: (status) => ({ panels: toPanels(status), chips: toChips(status) }),
+ *   });
+ *   onDestroy(feed.dispose);
+ * </script>
+ *
+ * <SystemStatusChips chips={feed.chips} />
+ * <SystemScopePanel panels={feed.panels} />
+ * ```
+ */
+const DEFAULT_INTERVAL_MS = 5000;
+/**
+ * Create a polling feed that maps an app status endpoint into the AdminShell
+ * system-scope presentation contracts.
+ *
+ * The returned {@link SystemFeedController} exposes reactive `panels` / `chips`
+ * and a `dispose()` disposer. Bind the getters to the shell components and call
+ * `dispose()` on teardown.
+ */
+export function systemFeed(options) {
+    const { fetch: fetcher, map, intervalMs = DEFAULT_INTERVAL_MS, immediate = true, pauseWhenHidden = true, onError, } = options;
+    let panels = $state([]);
+    let chips = $state([]);
+    let status = $state('idle');
+    let error = $state(null);
+    let running = $state(false);
+    // Non-reactive machinery.
+    let timer = null;
+    let inFlight = null;
+    let disposed = false;
+    // Guards against a slow tick resolving after a newer one (or after dispose)
+    // and clobbering fresher state.
+    let generation = 0;
+    const hasDocument = typeof document !== 'undefined';
+    const usesVisibility = pauseWhenHidden && hasDocument;
+    async function tick() {
+        if (disposed)
+            return;
+        // When hidden, skip the network entirely; the visibility listener will
+        // refresh on the way back to visible.
+        if (usesVisibility && document.hidden)
+            return;
+        const myGeneration = ++generation;
+        // Supersede any still-running fetch so its result can't land late.
+        inFlight?.abort();
+        const controller = new AbortController();
+        inFlight = controller;
+        status = 'loading';
+        try {
+            const raw = await fetcher(controller.signal);
+            if (disposed || myGeneration !== generation)
+                return;
+            const view = map(raw);
+            if (disposed || myGeneration !== generation)
+                return;
+            if (view.panels)
+                panels = view.panels;
+            if (view.chips)
+                chips = view.chips;
+            error = null;
+            status = 'success';
+        }
+        catch (caught) {
+            if (disposed || myGeneration !== generation)
+                return;
+            // An abort is an intentional supersede/teardown, not a feed failure.
+            if (isAbortError(caught))
+                return;
+            error = caught;
+            status = 'error';
+            // Contain a throwing consumer callback: it must not reject the tick and
+            // surface as an unhandled rejection from the interval / visibility path.
+            try {
+                onError?.(caught);
+            }
+            catch {
+                // Swallow — the feed's own error handling already recorded `caught`.
+            }
+        }
+        finally {
+            if (inFlight === controller)
+                inFlight = null;
+        }
+    }
+    function start() {
+        if (disposed || running)
+            return;
+        // Arm a timer only in a DOM environment (never spin a server-side interval
+        // during SSR) and only when an interval is requested. `running` reflects an
+        // actually-armed timer, so it stays false for single-shot feeds
+        // (`intervalMs <= 0`) and under SSR.
+        if (!hasDocument || intervalMs <= 0)
+            return;
+        running = true;
+        timer = setInterval(() => void tick(), intervalMs);
+    }
+    function stop() {
+        running = false;
+        if (timer !== null) {
+            clearInterval(timer);
+            timer = null;
+        }
+    }
+    function handleVisibility() {
+        // Only catch up on becoming visible while actively polling — a stopped
+        // (or disposed) feed must stay quiet.
+        if (disposed || !running)
+            return;
+        if (!document.hidden)
+            void tick();
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        stop();
+        // Invalidate any in-flight tick and abort its fetch.
+        generation++;
+        inFlight?.abort();
+        inFlight = null;
+        if (usesVisibility) {
+            document.removeEventListener('visibilitychange', handleVisibility);
+        }
+        status = 'stopped';
+    }
+    // Everything below activates the feed. Under SSR (no `document`) the feed is
+    // created inert — no listener, no immediate fetch, no timer — so a consumer
+    // can safely construct it in a component script; the client re-runs this and
+    // brings it to life. Callers can also drive an inert feed manually via
+    // `refresh()` / `start()`.
+    if (hasDocument) {
+        if (usesVisibility) {
+            document.addEventListener('visibilitychange', handleVisibility);
+        }
+        if (immediate)
+            void tick();
+        start();
+    }
+    return {
+        get panels() {
+            return panels;
+        },
+        get chips() {
+            return chips;
+        },
+        get status() {
+            return status;
+        },
+        get error() {
+            return error;
+        },
+        get running() {
+            return running;
+        },
+        refresh: tick,
+        start,
+        stop,
+        dispose,
+    };
+}
+function isAbortError(error) {
+    // Guard `DOMException` — it is undefined in some non-DOM runtimes, so a bare
+    // `instanceof` would throw a ReferenceError and defeat the SSR-safe contract.
+    if (typeof DOMException !== 'undefined' && error instanceof DOMException) {
+        return error.name === 'AbortError';
+    }
+    return (typeof error === 'object' &&
+        error !== null &&
+        'name' in error &&
+        error.name === 'AbortError');
+}

package/dist/i18n/strings.workspace.d.ts

@@ -56,5 +56,31 @@ export declare const M: {
     readonly 'ui.system_scope_panel.no_running_work': "ui.system_scope_panel.no_running_work";
     readonly 'ui.system_status_chips.system_status': "ui.system_status_chips.system_status";
     readonly 'ui.tenant_nav.tenant_navigation': "ui.tenant_nav.tenant_navigation";
+    readonly 'ui.activity_feed.title': "ui.activity_feed.title";
+    readonly 'ui.activity_feed.description': "ui.activity_feed.description";
+    readonly 'ui.activity_feed.enqueue_job': "ui.activity_feed.enqueue_job";
+    readonly 'ui.activity_feed.advance_job': "ui.activity_feed.advance_job";
+    readonly 'ui.activity_feed.complete_job': "ui.activity_feed.complete_job";
+    readonly 'ui.activity_feed.fail_job': "ui.activity_feed.fail_job";
+    readonly 'ui.activity_feed.clear_finished': "ui.activity_feed.clear_finished";
+    readonly 'ui.activity_feed.rows_heading': "ui.activity_feed.rows_heading";
+    readonly 'ui.activity_feed.no_rows': "ui.activity_feed.no_rows";
+    readonly 'ui.activity_feed.job_label': "ui.activity_feed.job_label";
+    readonly 'ui.system_feed.title': "ui.system_feed.title";
+    readonly 'ui.system_feed.description': "ui.system_feed.description";
+    readonly 'ui.system_feed.pause': "ui.system_feed.pause";
+    readonly 'ui.system_feed.resume': "ui.system_feed.resume";
+    readonly 'ui.system_feed.refresh': "ui.system_feed.refresh";
+    readonly 'ui.system_feed.fail_next': "ui.system_feed.fail_next";
+    readonly 'ui.system_feed.status_label': "ui.system_feed.status_label";
+    readonly 'ui.system_feed.tick_label': "ui.system_feed.tick_label";
+    readonly 'ui.system_feed.error_label': "ui.system_feed.error_label";
+    readonly 'ui.system_feed.jobs_panel': "ui.system_feed.jobs_panel";
+    readonly 'ui.system_feed.schedules_panel': "ui.system_feed.schedules_panel";
+    readonly 'ui.system_feed.dispatch_panel': "ui.system_feed.dispatch_panel";
+    readonly 'ui.system_feed.chip_workers': "ui.system_feed.chip_workers";
+    readonly 'ui.system_feed.chip_running': "ui.system_feed.chip_running";
+    readonly 'ui.system_feed.chip_queued': "ui.system_feed.chip_queued";
+    readonly 'ui.system_feed.chip_failed': "ui.system_feed.chip_failed";
 };
 //# sourceMappingURL=strings.workspace.d.ts.map

package/dist/i18n/strings.workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.workspace.d.ts","sourceRoot":"","sources":["../../src/i18n/strings.workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDZ,CAAC"}
+{"version":3,"file":"strings.workspace.d.ts","sourceRoot":"","sources":["../../src/i18n/strings.workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFZ,CAAC"}

package/dist/i18n/strings.workspace.js

@@ -61,4 +61,32 @@ export const M = defineMessages({
     'ui.system_scope_panel.no_running_work': 'No running work',
     'ui.system_status_chips.system_status': 'System status',
     'ui.tenant_nav.tenant_navigation': 'Tenant navigation',
+    // web/activity-feed adapter demo (#1779) — playground/admin-shell-activity-feed
+    'ui.activity_feed.title': 'Live activity feed',
+    'ui.activity_feed.description': 'A smrt-web live collection reconciled into the shell activity registry.',
+    'ui.activity_feed.enqueue_job': 'Enqueue job',
+    'ui.activity_feed.advance_job': 'Advance job',
+    'ui.activity_feed.complete_job': 'Complete job',
+    'ui.activity_feed.fail_job': 'Fail job',
+    'ui.activity_feed.clear_finished': 'Clear finished',
+    'ui.activity_feed.rows_heading': 'Backing collection rows',
+    'ui.activity_feed.no_rows': 'No rows yet',
+    'ui.activity_feed.job_label': 'Render job',
+    // components/workspace/live/* (systemFeed demo — issue #1774)
+    'ui.system_feed.title': 'System feed',
+    'ui.system_feed.description': 'Polls an app-provided status endpoint and maps it into the system-scope panels and status chips.',
+    'ui.system_feed.pause': 'Pause polling',
+    'ui.system_feed.resume': 'Resume polling',
+    'ui.system_feed.refresh': 'Refresh now',
+    'ui.system_feed.fail_next': 'Fail next fetch',
+    'ui.system_feed.status_label': 'Feed status',
+    'ui.system_feed.tick_label': 'Ticks',
+    'ui.system_feed.error_label': 'Last error',
+    'ui.system_feed.jobs_panel': 'Jobs',
+    'ui.system_feed.schedules_panel': 'Schedules',
+    'ui.system_feed.dispatch_panel': 'Dispatch',
+    'ui.system_feed.chip_workers': 'Workers',
+    'ui.system_feed.chip_running': 'Running',
+    'ui.system_feed.chip_queued': 'Queued',
+    'ui.system_feed.chip_failed': 'Failed',
 });

package/dist/web/__tests__/activity-feed-harness.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+/**
+ * Integration harness — invokes activityFeed() inside a component-init scope so
+ * the `$effect` it (and the underlying `liveCollection`) installs wires up to a
+ * real component lifecycle, then hands the feed handle back to the test.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import type { ShellState } from '../../components/workspace/index.js';
+import {
+  type ActivityFeedHandle,
+  type ActivityFeedMap,
+  activityFeed,
+} from '../activity-feed.svelte.js';
+
+interface Props {
+  collection: SmrtWebCollection<Record<string, unknown>>;
+  shell: ShellState;
+  map: ActivityFeedMap<Record<string, unknown>>;
+  onReady: (handle: ActivityFeedHandle) => void;
+}
+
+const props: Props = $props();
+// This harness intentionally snapshots its props during setup.
+// svelte-ignore state_referenced_locally
+const handle = activityFeed({
+  collection: props.collection,
+  shell: props.shell,
+  map: props.map,
+});
+// svelte-ignore state_referenced_locally
+props.onReady(handle);
+</script>

package/dist/web/__tests__/activity-feed-harness.svelte.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Integration harness — invokes activityFeed() inside a component-init scope so
+ * the `$effect` it (and the underlying `liveCollection`) installs wires up to a
+ * real component lifecycle, then hands the feed handle back to the test.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import type { ShellState } from '../../components/workspace/index.js';
+import { type ActivityFeedHandle, type ActivityFeedMap } from '../activity-feed.svelte.js';
+interface Props {
+    collection: SmrtWebCollection<Record<string, unknown>>;
+    shell: ShellState;
+    map: ActivityFeedMap<Record<string, unknown>>;
+    onReady: (handle: ActivityFeedHandle) => void;
+}
+declare const ActivityFeedHarness: import("svelte").Component<Props, {}, "">;
+type ActivityFeedHarness = ReturnType<typeof ActivityFeedHarness>;
+export default ActivityFeedHarness;
+//# sourceMappingURL=activity-feed-harness.svelte.d.ts.map

package/dist/web/__tests__/activity-feed-harness.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-feed-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/activity-feed-harness.svelte.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAErB,MAAM,4BAA4B,CAAC;AAGpC,UAAU,KAAK;IACb,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9C,OAAO,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC/C;AAsBD,QAAA,MAAM,mBAAmB,2CAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/web/__tests__/activity-feed.integration.svelte.test.js

@@ -0,0 +1,189 @@
+/**
+ * Integration test for the AdminShell activity feed adapter (#1779) end to end.
+ *
+ * Unlike the reconciler unit tests (which feed plain arrays), this exercises the
+ * FULL stack — `activityFeed` → `liveCollection` → the real `@happyvertical/smrt-web`
+ * collection with its client-data engine — through a mounted harness, so the
+ * `$effect` that drives reconciliation has a genuine component-init scope. Only
+ * the network boundary is mocked (the generated REST fetchers passed to
+ * `createSmrtCollection`); the engine, live view, runes reactivity, and the real
+ * `ShellState` are all live. This proves the reactive wiring drives the shell:
+ * a loaded row and an optimistic insert both surface as shell activities.
+ */
+import { createSmrtCollection, } from '@happyvertical/smrt-web';
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createShellState } from '../../components/workspace/admin-shell/state.svelte.js';
+import Harness from './activity-feed-harness.svelte';
+function jobDefinition(name) {
+    return {
+        name,
+        className: 'RenderJob',
+        endpoint: `/${name}`,
+        idField: 'id',
+        actions: ['create', 'get', 'list'],
+        fields: {
+            title: { type: 'text', required: true },
+            state: { type: 'text' },
+        },
+    };
+}
+/** Scripted stand-in for the generated REST fetchers (see live-collection test). */
+function makeScriptedFetchers(initialRows) {
+    const serverRows = [...initialRows];
+    const fetchers = {
+        list: async () => serverRows.map((row) => ({ ...row })),
+        create: async (data) => {
+            const created = { ...data, id: `server-${serverRows.length + 1}` };
+            serverRows.push(created);
+            return { ...created };
+        },
+    };
+    return { fetchers };
+}
+const mapJob = (row) => ({
+    kind: 'render-job',
+    scope: 'focus',
+    label: row.title,
+    status: row.state ?? 'running',
+});
+function mountFeed(collection, shell) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    let exposed = undefined;
+    const component = mount(Harness, {
+        target,
+        props: {
+            // The harness is typed against the base object shape; JobData is a
+            // structural subtype, so this cross-cast is purely nominal.
+            collection: collection,
+            shell,
+            map: mapJob,
+            onReady: (handle) => {
+                exposed = handle;
+            },
+        },
+    });
+    return {
+        handle: exposed,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('activityFeed (integration)', () => {
+    const cleanup = [];
+    afterEach(() => {
+        for (const fn of cleanup.splice(0))
+            fn();
+    });
+    it('reconciles loaded collection rows into shell activities', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-load'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        const activities = shell.listActivities();
+        expect(activities.map((a) => a.id).sort()).toEqual(['job-1', 'job-2']);
+        expect(activities.every((a) => a.kind === 'render-job')).toBe(true);
+        // Homed to the focus edge (right) per the map's scope.
+        expect(shell.listActivities({ edge: 'right' })).toHaveLength(2);
+    });
+    it('surfaces an optimistic insert as a shell activity reactively', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-insert'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(1);
+        // An optimistic insert appears in the live view synchronously → the feed
+        // reconciles it into the shell on the reactive tick.
+        const tx = collection.insert({
+            id: 'local-1',
+            title: 'Render credits',
+            state: 'running',
+        });
+        flushSync();
+        expect(shell
+            .listActivities()
+            .map((a) => a.label)
+            .sort()).toEqual(['Render credits', 'Render intro']);
+        // Once persisted, the server-assigned row replaces the optimistic one; the
+        // activity for the temp id is removed and the server row's activity remains.
+        await tx.isPersisted.promise;
+        flushSync();
+        const labels = shell
+            .listActivities()
+            .map((a) => a.label)
+            .sort();
+        expect(labels).toEqual(['Render credits', 'Render intro']);
+        // The optimistic-id activity is gone; the server id is present.
+        const ids = shell.listActivities().map((a) => a.id);
+        expect(ids).toContain('server-2');
+        expect(ids).not.toContain('local-1');
+    });
+    it('dispose() retracts the feed activities from the shell', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-dispose'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(1);
+        mounted.handle.dispose();
+        expect(shell.listActivities()).toHaveLength(0);
+        expect(mounted.handle.isDisposed).toBe(true);
+    });
+    it('auto-retracts the feed activities when the host component unmounts', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-unmount'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        // An activity from another source must survive the feed's unmount.
+        shell.upsertActivity({
+            id: 'external-1',
+            label: 'External',
+            kind: 'other',
+            scope: 'app',
+            status: 'running',
+        });
+        const mounted = mountFeed(collection, shell);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(3);
+        // Unmount WITHOUT calling dispose() manually: the adapter's $effect teardown
+        // must retract exactly its own activities, leaving the external one intact.
+        mounted.teardown();
+        flushSync();
+        const remaining = shell.listActivities();
+        expect(remaining).toHaveLength(1);
+        expect(remaining[0].id).toBe('external-1');
+    });
+});