@cosmicdrift/kumiko-headless 0.328.0 → 0.328.1

package/src/nav/__tests__/resolve.test.ts

@@ -1,279 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { NavDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import { resolveNavigation } from "../resolve";
-import type { NavRegistrySlice } from "../types";
-
-// Builds the minimal NavRegistrySlice resolveNavigation consumes from a
-// flat NavDefinition list. Shape matches what the framework registry
-// exposes: `topLevel` collects entries without a parent, `byParent`
-// looks up children by qualified parent-id. Ids in the list MUST already
-// be qualified ("feature:nav:short") — that's what the registry hands
-// back, so tests here mirror it 1:1.
-function buildSource(navs: readonly NavDefinition[]): NavRegistrySlice {
-  const byParent = new Map<string, NavDefinition[]>();
-  const topLevel: NavDefinition[] = [];
-  for (const nav of navs) {
-    if (nav.parent) {
-      const bucket = byParent.get(nav.parent);
-      if (bucket) bucket.push(nav);
-      else byParent.set(nav.parent, [nav]);
-    } else {
-      topLevel.push(nav);
-    }
-  }
-  return {
-    topLevel,
-    byParent: (qn) => byParent.get(qn) ?? [],
-  };
-}
-
-const userAdmin = { id: "u-admin", roles: ["Admin"] };
-const userStandard = { id: "u-std", roles: ["User"] };
-
-describe("resolveNavigation", () => {
-  test("flat list: all top-level entries become root nodes", () => {
-    const source = buildSource([
-      { id: "orders:nav:list", label: "Orders", screen: "orders:screen:order-list" },
-      { id: "orders:nav:dashboard", label: "Home" },
-    ]);
-
-    const tree = resolveNavigation({ source });
-
-    expect(tree).toHaveLength(2);
-    expect(tree.map((n) => n.qualifiedName).sort()).toEqual([
-      "orders:nav:dashboard",
-      "orders:nav:list",
-    ]);
-    expect(tree.every((n) => n.children.length === 0)).toBe(true);
-  });
-
-  test("parent refs assemble the tree — one level deep", () => {
-    const source = buildSource([
-      { id: "app:nav:ops", label: "Operations" },
-      {
-        id: "app:nav:ops-orders",
-        label: "Orders",
-        parent: "app:nav:ops",
-        screen: "orders:screen:order-list",
-      },
-      {
-        id: "app:nav:ops-shipments",
-        label: "Shipments",
-        parent: "app:nav:ops",
-        screen: "ship:screen:ship-list",
-      },
-    ]);
-
-    const tree = resolveNavigation({ source });
-
-    expect(tree).toHaveLength(1);
-    const ops = tree[0];
-    expect(ops?.qualifiedName).toBe("app:nav:ops");
-    expect(ops?.children).toHaveLength(2);
-    expect(ops?.children.map((c) => c.qualifiedName).sort()).toEqual([
-      "app:nav:ops-orders",
-      "app:nav:ops-shipments",
-    ]);
-  });
-
-  test("sort order: `order` ASC, ties broken by qualifiedName alphabetic", () => {
-    const source = buildSource([
-      { id: "app:nav:alpha", label: "A", order: 10 },
-      { id: "app:nav:beta", label: "B", order: 5 },
-      { id: "app:nav:charlie", label: "C", order: 5 }, // same order as beta
-    ]);
-
-    const tree = resolveNavigation({ source });
-
-    // beta (order=5) and charlie (order=5) first, both alphabetical, then alpha
-    expect(tree.map((n) => n.qualifiedName)).toEqual([
-      "app:nav:beta",
-      "app:nav:charlie",
-      "app:nav:alpha",
-    ]);
-  });
-
-  test("access: role-gated entries drop out for non-matching users", () => {
-    const source = buildSource([
-      { id: "app:nav:public", label: "Public" },
-      { id: "app:nav:admin-only", label: "Admin Area", access: { roles: ["Admin"] } },
-    ]);
-
-    const adminTree = resolveNavigation({ source, user: userAdmin });
-    expect(adminTree.map((n) => n.qualifiedName).sort()).toEqual([
-      "app:nav:admin-only",
-      "app:nav:public",
-    ]);
-
-    const stdTree = resolveNavigation({ source, user: userStandard });
-    expect(stdTree.map((n) => n.qualifiedName)).toEqual(["app:nav:public"]);
-  });
-
-  test("access: openToAll bypasses user-role check (matches handler-access semantic)", () => {
-    const source = buildSource([
-      {
-        id: "app:nav:help",
-        label: "Help",
-        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
-      },
-    ]);
-
-    // Anonymous sees it.
-    expect(resolveNavigation({ source })).toHaveLength(1);
-    // Standard user sees it.
-    expect(resolveNavigation({ source, user: userStandard })).toHaveLength(1);
-  });
-
-  test("access: no user + role-gated entry → dropped (anonymous can't satisfy roles)", () => {
-    const source = buildSource([
-      { id: "app:nav:gated", label: "Gated", access: { roles: ["Admin"] } },
-    ]);
-
-    expect(resolveNavigation({ source })).toHaveLength(0);
-  });
-
-  test("hidden parent hides descendants (no orphaned children)", () => {
-    // "Reports" is Admin-only; the child "Sales Report" has no access rule
-    // (would be publicly visible by itself). With the parent gone, the
-    // child drops too — the resolver never recurses into a hidden node,
-    // so a lone link without its containing group can't appear.
-    const source = buildSource([
-      { id: "app:nav:reports", label: "Reports", access: { roles: ["Admin"] } },
-      {
-        id: "app:nav:sales-report",
-        label: "Sales",
-        parent: "app:nav:reports",
-        screen: "reports:screen:sales",
-      },
-    ]);
-
-    const tree = resolveNavigation({ source, user: userStandard });
-    expect(tree).toHaveLength(0);
-  });
-
-  test("entries pass through label/icon/screen verbatim — renderer translates label", () => {
-    const source = buildSource([
-      {
-        id: "app:nav:orders",
-        label: "orders:i18n:nav.orders",
-        icon: "package",
-        screen: "orders:screen:list",
-        order: 1,
-      },
-    ]);
-
-    const [node] = resolveNavigation({ source });
-    expect(node?.label).toBe("orders:i18n:nav.orders");
-    expect(node?.icon).toBe("package");
-    expect(node?.screen).toBe("orders:screen:list");
-    expect(node?.order).toBe(1);
-  });
-
-  test("order default is 0 on the NavNode when not provided", () => {
-    const source = buildSource([{ id: "app:nav:x", label: "X" }]);
-    expect(resolveNavigation({ source })[0]?.order).toBe(0);
-  });
-
-  test("dangling parent ref → child never reached (boot-validator should catch upstream)", () => {
-    // "orphan" has parent="missing"; "missing" is not registered.
-    // Because the walk is top-down, orphan sits only in byParent("missing")
-    // and byParent is never called for "missing" (it's not in topLevel,
-    // it's not reachable). So the child naturally drops.
-    const source = buildSource([
-      { id: "app:nav:orphan", label: "Orphan", parent: "app:nav:missing" },
-    ]);
-
-    expect(resolveNavigation({ source })).toHaveLength(0);
-  });
-
-  test("empty registry → empty tree", () => {
-    const source: NavRegistrySlice = { topLevel: [], byParent: () => [] };
-    expect(resolveNavigation({ source })).toEqual([]);
-  });
-
-  test("deeper nesting: three levels compose correctly", () => {
-    const source = buildSource([
-      { id: "a:nav:root", label: "Root" },
-      { id: "a:nav:mid", label: "Mid", parent: "a:nav:root" },
-      { id: "a:nav:leaf", label: "Leaf", parent: "a:nav:mid", screen: "a:screen:x" },
-    ]);
-
-    const tree = resolveNavigation({ source });
-    expect(tree[0]?.qualifiedName).toBe("a:nav:root");
-    expect(tree[0]?.children[0]?.qualifiedName).toBe("a:nav:mid");
-    expect(tree[0]?.children[0]?.children[0]?.qualifiedName).toBe("a:nav:leaf");
-  });
-
-  // Visual-Tree-Merge: die polymorphen Felder (target/actions/createAction/
-  // provider) müssen durch resolveNavigation durchgereicht werden, sonst
-  // kann der eine Renderer dynamische/dispatch-Knoten nicht bauen.
-  test("polymorphic fields pass through: target, actions, createAction, provider", () => {
-    const editTarget = { featureId: "text-content", action: "edit", args: { slug: "hero" } };
-    const createTarget = { featureId: "text-content", action: "create", args: { folder: "page" } };
-    const source = buildSource([
-      {
-        id: "tc:nav:content",
-        label: "Content",
-        provider: true,
-        createAction: { icon: "plus", label: "New page", target: createTarget },
-      },
-      {
-        id: "tc:nav:hero",
-        label: "Hero",
-        parent: "tc:nav:content",
-        target: editTarget,
-        actions: [{ icon: "trash", label: "Delete", target: editTarget }],
-      },
-    ]);
-
-    const tree = resolveNavigation({ source });
-    const content = tree[0];
-    expect(content?.provider).toBe(true);
-    expect(content?.createAction?.target).toEqual(createTarget);
-    const hero = content?.children[0];
-    expect(hero?.target).toEqual(editTarget);
-    expect(hero?.screen).toBeUndefined();
-    expect(hero?.actions).toHaveLength(1);
-  });
-
-  // fw#2750: a TreeAction can also carry `screen` (route link) instead of
-  // `target` (dispatch) — same polymorphism as the node itself.
-  test("action `screen` (route-link variant) passes through alongside target-based actions", () => {
-    const editTarget = { featureId: "text-content", action: "edit", args: { slug: "hero" } };
-    const source = buildSource([
-      {
-        id: "tc:nav:content",
-        label: "Content",
-        provider: true,
-        createAction: { icon: "plus", label: "New page", screen: "tc:screen:new-page" },
-      },
-      {
-        id: "tc:nav:hero",
-        label: "Hero",
-        parent: "tc:nav:content",
-        target: editTarget,
-        actions: [{ icon: "edit", label: "Edit in editor", screen: "tc:screen:hero" }],
-      },
-    ]);
-
-    const tree = resolveNavigation({ source });
-    const content = tree[0];
-    expect(content?.createAction?.screen).toBe("tc:screen:new-page");
-    expect(content?.createAction?.target).toBeUndefined();
-    const hero = content?.children[0];
-    expect(hero?.actions?.[0]?.screen).toBe("tc:screen:hero");
-    expect(hero?.actions?.[0]?.target).toBeUndefined();
-  });
-
-  // A node without the polymorphic fields must NOT carry them as
-  // undefined-valued keys (conditional-spread): keeps the resolved node
-  // clean and snapshot-stable.
-  test("absent polymorphic fields are omitted, not set to undefined", () => {
-    const source = buildSource([{ id: "a:nav:plain", label: "Plain", screen: "a:screen:x" }]);
-    const node = resolveNavigation({ source })[0];
-    expect(node).not.toBeUndefined();
-    expect("target" in (node ?? {})).toBe(false);
-    expect("provider" in (node ?? {})).toBe(false);
-    expect("actions" in (node ?? {})).toBe(false);
-  });
-});

package/src/nav/index.ts

@@ -1,8 +0,0 @@
-export { resolveNavigation } from "./resolve";
-export type {
-  NavDefinition,
-  NavNode,
-  NavRegistrySlice,
-  NavTree,
-  ResolveNavigationOptions,
-} from "./types";

package/src/nav/resolve.ts

@@ -1,60 +0,0 @@
-import type { NavDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
-import type { NavNode, NavTree, ResolveNavigationOptions } from "./types";
-
-// Assembles the renderable nav tree from the registry's pre-grouped
-// indexes (topLevel + byParent). Walks top-down: each node is
-// access-checked; a hidden parent drops its entire subtree implicitly
-// because we never recurse into it. Siblings sort by `order` (ascending,
-// default 0), tie-broken by qualified name so renders stay deterministic
-// across registry iteration orders.
-//
-// Pure — same inputs produce the same tree. The renderer memoizes the
-// result and only recomputes when the registry changes (rare — boot
-// only) or the user's roles change (logout/login, tenant-switch).
-export function resolveNavigation(options: ResolveNavigationOptions): NavTree {
-  const { source, user } = options;
-
-  function build(entry: NavDefinition): NavNode | null {
-    // Shared default-visible UI predicate, not hasAccess from the engine:
-    // that module pulls server-side deps and would break bundle purity.
-    if (!isUiAccessGranted(entry.access, user?.roles)) return null;
-    // `entry.id` is already the qualified name — the registry stores
-    // it that way. No reverse-index lookup needed.
-    const children: NavNode[] = [];
-    for (const child of source.byParent(entry.id)) {
-      const node = build(child);
-      if (node !== null) children.push(node);
-    }
-    children.sort(bySortKey);
-    return {
-      qualifiedName: entry.id,
-      label: entry.label,
-      order: entry.order ?? 0,
-      children,
-      ...(entry.icon !== undefined && { icon: entry.icon }),
-      ...(entry.screen !== undefined && { screen: entry.screen }),
-      ...(entry.target !== undefined && { target: entry.target }),
-      ...(entry.actions !== undefined && { actions: entry.actions }),
-      ...(entry.createAction !== undefined && { createAction: entry.createAction }),
-      ...(entry.provider !== undefined && { provider: entry.provider }),
-    };
-  }
-
-  const roots: NavNode[] = [];
-  for (const entry of source.topLevel) {
-    const node = build(entry);
-    if (node !== null) roots.push(node);
-  }
-  roots.sort(bySortKey);
-  return roots;
-}
-
-function bySortKey(a: NavNode, b: NavNode): number {
-  // Primary key: `order` ascending. Secondary: qualifiedName alphabetic,
-  // which is a stable fallback — the registry-iteration order isn't
-  // guaranteed across boots, so tied-order entries would otherwise
-  // shuffle between renders.
-  if (a.order !== b.order) return a.order - b.order;
-  return a.qualifiedName.localeCompare(b.qualifiedName);
-}

package/src/nav/types.ts

@@ -1,70 +0,0 @@
-import type { NavDefinition, TargetRef, TreeAction } from "@cosmicdrift/kumiko-framework/ui-types";
-
-// A single resolved nav entry as the renderer consumes it. Labels are NOT
-// translated yet — nav can be used in SSR contexts where the locale isn't
-// known at resolve time; the renderer runs `label` through
-// LocaleResolver.translate() when it draws the sidebar/topbar item.
-//
-// Identity: `qualifiedName` is the same QN the registry uses
-// ("{feature}:nav:{id}"). Renderers key off this for active-route tracking
-// and for `parent` matching in screen extensions (M4).
-export type NavNode = {
-  readonly qualifiedName: string;
-  readonly label: string;
-  readonly icon?: string;
-  readonly screen?: string;
-  // Polymorphes Klick-Ziel (EditorPanel via dispatch) — Alternative zu
-  // `screen`. Knoten trägt screen XOR target.
-  readonly target?: TargetRef;
-  // Hover-Actions + „+"-Affordance, durchgereicht aus der NavDefinition.
-  readonly actions?: readonly TreeAction[];
-  readonly createAction?: TreeAction;
-  // true → Children kommen zur Laufzeit aus einem nav-provider (lazy +
-  // SSE-live), nicht aus `children`. Renderer macht den Knoten expandable.
-  readonly provider?: boolean;
-  readonly order: number;
-  readonly children: readonly NavNode[];
-};
-
-// The tree returned by resolveNavigation. Empty when the user can see no
-// entries — renderer draws a fallback ("no navigation available" or just
-// a blank sidebar, app decision).
-export type NavTree = readonly NavNode[];
-
-// Minimal registry surface resolveNavigation reads from. Deliberately
-// narrower than the full Registry — keeps the resolver test-friendly
-// (callers can stub with a two-field plain object) and pins the
-// coupling to just the two index-accessors the resolver actually uses:
-//
-//   - `topLevel` : roots list (entries with no parent). Pre-grouped in
-//                  the registry — resolver starts its walk here.
-//   - `byParent` : O(1) children lookup by parent qualified name. The
-//                  walk descends into this for each node; access-gating
-//                  happens top-down, so a hidden parent implicitly
-//                  hides the whole subtree.
-//
-// Note: the registry stores each NavDefinition with its `id` already
-// qualified ("feature:nav:short"); resolveNavigation reads that directly.
-//
-// Production callers pass:
-//   { topLevel: registry.getTopLevelNavs(),
-//     byParent: (qn) => registry.getNavsByParent(qn) }
-export type NavRegistrySlice = {
-  readonly topLevel: readonly NavDefinition[];
-  readonly byParent: (parentQualifiedName: string) => readonly NavDefinition[];
-};
-
-// Options passed to resolveNavigation.
-export type ResolveNavigationOptions = {
-  readonly source: NavRegistrySlice;
-  // Current session user. Access-rule enforcement compares
-  // rule.roles against user.roles. When user is undefined, ONLY
-  // entries with access.openToAll === true (or no access declared)
-  // survive — matches the "anonymous visit" semantic.
-  readonly user?: {
-    readonly id: string;
-    readonly roles: readonly string[];
-  };
-};
-
-export type { NavDefinition };

package/src/store/__tests__/create-store.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import { createStore } from "../create-store";
-
-describe("createStore — snapshot & setState", () => {
-  test("getSnapshot returns the initial value", () => {
-    const store = createStore({ count: 0 });
-    expect(store.getSnapshot()).toEqual({ count: 0 });
-  });
-
-  test("setState with a value updates the snapshot", () => {
-    const store = createStore({ count: 0 });
-    store.setState({ count: 5 });
-    expect(store.getSnapshot()).toEqual({ count: 5 });
-  });
-
-  test("setState with a reducer receives the current snapshot", () => {
-    const store = createStore({ count: 3 });
-    store.setState((prev) => ({ count: prev.count + 1 }));
-    expect(store.getSnapshot()).toEqual({ count: 4 });
-  });
-
-  test("getSnapshot returns stable reference when value unchanged (Object.is gate)", () => {
-    const initial = { count: 0 };
-    const store = createStore(initial);
-    const before = store.getSnapshot();
-    store.setState(initial); // same reference
-    expect(store.getSnapshot()).toBe(before);
-  });
-});
-
-describe("createStore — subscribe & notify", () => {
-  test("subscribed listener fires on setState", () => {
-    const store = createStore({ count: 0 });
-    const listener = mock();
-    store.subscribe(listener);
-
-    store.setState({ count: 1 });
-
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  test("multiple listeners all fire on setState", () => {
-    const store = createStore({ count: 0 });
-    const a = mock();
-    const b = mock();
-    store.subscribe(a);
-    store.subscribe(b);
-
-    store.setState({ count: 1 });
-
-    expect(a).toHaveBeenCalledTimes(1);
-    expect(b).toHaveBeenCalledTimes(1);
-  });
-
-  test("unsubscribe stops further notifications", () => {
-    const store = createStore({ count: 0 });
-    const listener = mock();
-    const unsub = store.subscribe(listener);
-
-    store.setState({ count: 1 });
-    unsub();
-    store.setState({ count: 2 });
-
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  test("Object.is-equal setState does NOT notify listeners", () => {
-    const store = createStore({ count: 0 });
-    const same = store.getSnapshot();
-    const listener = mock();
-    store.subscribe(listener);
-
-    // Same reference — gate blocks notification.
-    store.setState(same);
-    // Primitive-equal setState on primitive-valued store also no-ops.
-    const primStore = createStore(42);
-    const primListener = mock();
-    primStore.subscribe(primListener);
-    primStore.setState(42);
-
-    expect(listener).not.toHaveBeenCalled();
-    expect(primListener).not.toHaveBeenCalled();
-  });
-
-  test("setState inside reducer that returns same ref does NOT notify", () => {
-    const store = createStore({ count: 0 });
-    const listener = mock();
-    store.subscribe(listener);
-
-    store.setState((prev) => prev); // reducer returns same ref
-
-    expect(listener).not.toHaveBeenCalled();
-  });
-});
-
-describe("createStore — reentrancy safety", () => {
-  test("listener unsubscribing itself during callback does not break iteration", () => {
-    const store = createStore({ count: 0 });
-    const order: string[] = [];
-
-    const unsubA = store.subscribe(() => {
-      order.push("a");
-      unsubA(); // self-unsubscribe mid-loop
-    });
-    store.subscribe(() => {
-      order.push("b");
-    });
-
-    store.setState({ count: 1 });
-
-    // Both fire on this cycle; A must not prevent B from running.
-    expect(order).toEqual(["a", "b"]);
-
-    // A is gone; only B fires on the next cycle.
-    order.length = 0;
-    store.setState({ count: 2 });
-    expect(order).toEqual(["b"]);
-  });
-
-  test("listener unsubscribing ANOTHER listener mid-loop does not re-invoke it", () => {
-    const store = createStore({ count: 0 });
-    const order: string[] = [];
-
-    let unsubB: (() => void) | null = null;
-
-    store.subscribe(() => {
-      order.push("a");
-      unsubB?.(); // kill B before its turn
-    });
-    unsubB = store.subscribe(() => {
-      order.push("b");
-    });
-
-    store.setState({ count: 1 });
-
-    // B was unsubscribed by A before iteration reached it.
-    expect(order).toEqual(["a"]);
-  });
-});

package/src/store/__tests__/equality.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { shallowEqual } from "../equality";
-
-describe("shallowEqual — primitive cases", () => {
-  test("Object.is-equal primitives are equal", () => {
-    expect(shallowEqual(1, 1)).toBe(true);
-    expect(shallowEqual("a", "a")).toBe(true);
-    expect(shallowEqual(true, true)).toBe(true);
-    expect(shallowEqual(null, null)).toBe(true);
-    expect(shallowEqual(undefined, undefined)).toBe(true);
-  });
-
-  test("NaN equals NaN (Object.is semantics)", () => {
-    expect(shallowEqual(Number.NaN, Number.NaN)).toBe(true);
-  });
-
-  test("differing primitives are not equal", () => {
-    expect(shallowEqual(1, 2)).toBe(false);
-    expect(shallowEqual("a", "b")).toBe(false);
-    expect(shallowEqual(0, -0)).toBe(false); // Object.is distinguishes
-  });
-
-  test("primitive vs object is not equal", () => {
-    expect(shallowEqual(1, { 0: 1 })).toBe(false);
-    expect(shallowEqual(null, {})).toBe(false);
-    expect(shallowEqual({}, null)).toBe(false);
-  });
-});
-
-describe("shallowEqual — object cases", () => {
-  test("same reference is equal", () => {
-    const o = { a: 1 };
-    expect(shallowEqual(o, o)).toBe(true);
-  });
-
-  test("same keys + same values → equal", () => {
-    expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-  });
-
-  test("same keys, different value → not equal", () => {
-    expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-  });
-
-  test("different number of keys → not equal", () => {
-    expect(shallowEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
-    expect(shallowEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-  });
-
-  test("same count, different key names → not equal", () => {
-    expect(shallowEqual({ a: 1 }, { b: 1 })).toBe(false);
-  });
-
-  test("nested object: only top-level refs compared (shallow)", () => {
-    const inner = { x: 1 };
-    // Same nested ref → equal at top level.
-    expect(shallowEqual({ inner }, { inner })).toBe(true);
-    // Equivalent but distinct nested ref → NOT equal (shallow doesn't recurse).
-    expect(shallowEqual({ inner: { x: 1 } }, { inner: { x: 1 } })).toBe(false);
-  });
-
-  test("arrays compared as objects: same length + same values → equal", () => {
-    expect(shallowEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(shallowEqual([1, 2, 3], [1, 2, 4])).toBe(false);
-    expect(shallowEqual([1, 2], [1, 2, 3])).toBe(false);
-  });
-});

package/src/store/index.ts

@@ -1,3 +0,0 @@
-export { createStore } from "./create-store";
-export { shallowEqual } from "./equality";
-export type { Store, WritableStore } from "./types";

package/src/store/types.ts

@@ -1,27 +0,0 @@
-// Store contract — Pull-Style Subscribe/Emit matching React's
-// useSyncExternalStore signature. The single canonical shape for
-// every stateful controller in ui-core/renderer land (form,
-// dispatcher-status, locale, token, nav, lifecycle).
-//
-// Rationale in docs/plans/ui-store.md. Not a new state-management
-// decision — ui-decisions.md already picked Subscribe/Emit; this
-// module just materializes the pattern instead of rolling a new
-// Set<() => void> per controller.
-
-export type Store<T> = {
-  // Current snapshot. Referentially stable across no-op setState calls
-  // (see createStore's Object.is gate) so useSyncExternalStore doesn't
-  // re-render consumers when nothing actually changed.
-  getSnapshot(): T;
-  // Subscribe listener, returns unsubscribe. Listener receives no
-  // payload — it reads via getSnapshot(). Direct match for
-  // useSyncExternalStore's contract.
-  subscribe(listener: () => void): () => void;
-};
-
-export type WritableStore<T> = Store<T> & {
-  // Update with a new value or a reducer function. If the resulting
-  // snapshot is Object.is-equal to the current one, listeners are NOT
-  // notified — re-render prevention at the source.
-  setState(next: T | ((prev: T) => T)): void;
-};