feat(core): add prune API to clear event history

core/src/interfaces/StackflowActions.ts

@@ -62,4 +62,9 @@ export type StackflowActions = {
    * Resume paused stack
    */
   resume: (params?: Omit<ResumedEvent, keyof BaseDomainEvent>) => void;
+
+  /**
+   * Clear past events and reconstruct state with active activities to release memory
+   */
+  prune: () => void;
 };

core/src/makeCoreStore.spec.ts

@@ -281,3 +281,71 @@ test("makeCoreStore - subscribe에 등록한 이후에 아무 Event가 없는 
 
   expect(listener1).toHaveBeenCalledTimes(0);
 });
+
+test("makeCoreStore - prune이 호출되면, 과거의 이벤트를 정리하고 현재 상태를 유지합니다", () => {
+  const { actions, pullEvents } = makeCoreStore({
+    initialEvents: [
+      makeEvent("Initialized", {
+        transitionDuration: 0,
+        eventDate: enoughPastTime(),
+      }),
+      makeEvent("ActivityRegistered", {
+        activityName: "home",
+        eventDate: enoughPastTime(),
+      }),
+      makeEvent("ActivityRegistered", {
+        activityName: "detail",
+        eventDate: enoughPastTime(),
+      }),
+      makeEvent("Pushed", {
+        activityId: "a1",
+        activityName: "home",
+        activityParams: {},
+        eventDate: enoughPastTime(),
+      }),
+    ],
+    plugins: [],
+  });
+
+  // Push detail (a2)
+  actions.push({
+    activityId: "a2",
+    activityName: "detail",
+    activityParams: { id: "1" },
+  });
+
+  // Push detail (a3)
+  actions.push({
+    activityId: "a3",
+    activityName: "detail",
+    activityParams: { id: "2" },
+  });
+
+  // Pop a3 -> a3 becomes exit-done
+  actions.pop();
+
+  // Pop a2 -> a2 becomes exit-done
+  actions.pop();
+
+  // Now only a1 (home) is active
+  const stackBeforePrune = actions.getStack();
+  const eventsBeforePrune = pullEvents();
+
+  expect(stackBeforePrune.activities.length).toBe(3); // a1, a2, a3
+  expect(eventsBeforePrune.length).toBeGreaterThan(5);
+
+  // Prune!
+  actions.prune();
+
+  const stackAfterPrune = actions.getStack();
+  const eventsAfterPrune = pullEvents();
+
+  // Verify activities: only a1 should remain
+  expect(stackAfterPrune.activities.length).toBe(1);
+  expect(stackAfterPrune.activities[0].id).toEqual("a1");
+  expect(stackAfterPrune.activities[0].transitionState).toEqual("enter-done");
+
+  // Verify events: should be reset to minimal set
+  // Initialized + ActivityRegistered(home) + Pushed(a1) = 3 events
+  expect(eventsAfterPrune.length).toBe(3);
+});

core/src/makeCoreStore.ts

@@ -118,6 +118,7 @@ export function makeCoreStore(options: MakeCoreStoreOptions): CoreStore {
     stepPop: () => {},
     pause: () => {},
     resume: () => {},
+    prune: () => {},
   };
 
   const setStackValue = (nextStackValue: Stack) => {
@@ -133,6 +134,11 @@ export function makeCoreStore(options: MakeCoreStoreOptions): CoreStore {
       dispatchEvent: actions.dispatchEvent,
       pluginInstances,
       actions,
+      store: {
+        getStack: actions.getStack,
+        events,
+        setStackValue,
+      },
     }),
   );
 

core/src/utils/makeActions.ts

@@ -1,16 +1,26 @@
+import { aggregate } from "../aggregate";
+import type { DomainEvent } from "../event-types";
+import { makeEvent } from "../event-utils";
 import type { StackflowActions, StackflowPlugin } from "../interfaces";
+import type { Stack } from "../Stack";
 import { triggerPreEffectHook } from "./triggerPreEffectHooks";
 
 type ActionCreatorOptions = {
   dispatchEvent: StackflowActions["dispatchEvent"];
   pluginInstances: ReturnType<StackflowPlugin>[];
   actions: StackflowActions;
+  store: {
+    getStack: () => Stack;
+    events: { value: DomainEvent[] };
+    setStackValue: (stack: Stack) => void;
+  };
 };
 
 export function makeActions({
   dispatchEvent,
   pluginInstances,
   actions,
+  store,
 }: ActionCreatorOptions): Omit<StackflowActions, "dispatchEvent" | "getStack"> {
   return {
     push(params) {
@@ -125,5 +135,42 @@ export function makeActions({
 
       dispatchEvent("Resumed", nextActionParams);
     },
+    prune() {
+      const { activities } = store.getStack();
+      const activeActivities = activities.filter(
+        (activity) =>
+          activity.transitionState === "enter-active" ||
+          activity.transitionState === "enter-done",
+      );
+
+      const now = new Date().getTime();
+
+      const newEvents: DomainEvent[] = [
+        makeEvent("Initialized", {
+          transitionDuration: 0,
+          eventDate: now,
+        }),
+        ...activeActivities.map((activity) =>
+          makeEvent("ActivityRegistered", {
+            activityName: activity.name,
+            eventDate: now,
+          }),
+        ),
+        ...activeActivities.map((activity) =>
+          makeEvent("Pushed", {
+            activityId: activity.id,
+            activityName: activity.name,
+            activityParams: activity.params,
+            eventDate: now,
+            skipEnterActiveState: true,
+          }),
+        ),
+      ];
+
+      store.events.value = newEvents;
+
+      const nextStackValue = aggregate(store.events.value, now);
+      store.setStackValue(nextStackValue);
+    },
   };
 }