@astrale-os/shell-react 0.2.8 → 0.2.10-beta.2

package/src/window/host.tsx

@@ -1,9 +1,9 @@
-import type { NodeRefInput } from '@astrale-os/kernel-client'
 import type {
   CloseResult,
-  IntentRegistry,
+  HostCapabilities,
   MountCredential,
   MountParams,
+  ResolvedView,
   SandboxProfile,
   Window,
 } from '@astrale-os/shell'
@@ -14,7 +14,8 @@ import type { CSSProperties, ReactElement, ReactNode } from 'react'
  * projects that box onto a stage slot (ResizeObserver); the iframe lives in the
  * stage, so reorder/re-key never reloads a healthy frame. It drives the
  * `WindowState` machine, owns teardown (unmount closes its window), survives
- * StrictMode double-mount, and downgrades a fallbackable handshake to plain.
+ * StrictMode double-mount. The complete target-bound View is the sole source
+ * of mount identity, route, target, and handshake behavior.
  */
 import {
   forwardRef,
@@ -28,19 +29,12 @@ import {
 } from 'react'
 
 import type { AdoptRecord } from './adopt.js'
-import type { ViewSource } from './lifecycle/mount.js'
 import type { WindowState } from './lifecycle/states.js'
 import type { SlotRect, StageController, StageSlot } from './placement.js'
 
 import { useShell } from '../session/shell.hook.js'
 import { getStageHub } from './hub.js'
-import {
-  isFallbackableHandshakeError,
-  refToId,
-  resolveSource,
-  sendSetTarget,
-  sourceKey,
-} from './lifecycle/mount.js'
+import { viewMountKey } from './lifecycle/mount.js'
 import { rectOf, sameRect } from './placement.js'
 
 /** Imperative handle on a mounted `ViewHost` (API §10). */
@@ -51,12 +45,17 @@ export interface ViewHostHandle {
   refresh(): void
 }
 
-export type ViewHostProps = ViewSource & {
-  /** Node this view opens on — delivered as `targetNodeId`; a change retargets. */
-  node?: NodeRefInput
-  capabilities?: { intents: readonly (keyof IntentRegistry)[] }
-  sandbox?: SandboxProfile | null
+/** Static iframe sandbox flags, an explicit opt-out, or a policy over the resolved mount. */
+export type SandboxPolicy = SandboxProfile | null | ((view: ResolvedView) => SandboxProfile | null)
+
+export interface ViewHostProps {
+  /** One canonical target paired with one untouched View route. */
+  view: ResolvedView
+  capabilities?: HostCapabilities
+  sandbox?: SandboxPolicy
   credential?: MountCredential
+  handshakeTimeoutMs?: number
+  delegationTtlSeconds?: number
   /** Rendered inside the anchor while the frame is not `ready`. */
   fallback?: (state: WindowState) => ReactNode
   onStateChange?: (state: WindowState) => void
@@ -71,7 +70,6 @@ interface LiveWindow {
   readonly windowId: string
   readonly window: Window
   readonly state: WindowState
-  readonly targetId: string | undefined
 }
 
 export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
@@ -97,9 +95,7 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
     const [state, setState] = useState<WindowState>(MOUNTING)
     const [refreshNonce, setRefreshNonce] = useState(0)
 
-    const mountKey = sourceKey(props)
-    const targetId = refToId(props.node)
-    const lastTargetRef = useRef<string | undefined>(undefined)
+    const mountKey = viewMountKey(props.view)
 
     const setStateSafe = (next: WindowState) => {
       if (!aliveRef.current) return
@@ -155,10 +151,9 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
       slot.place(rect)
     }, [])
 
-    // ── Mount lifecycle. Keyed on the source identity + refresh nonce only — a
-    //    node (targetNodeId) change retargets via setTarget, never a remount. A
-    //    re-key/re-parent unmount+remount ADOPTS the live window through the hub
-    //    (deferred close), so a healthy iframe is never reloaded (§10).
+    // ── Mount lifecycle. Keyed on complete target + route provenance and
+    //    refresh nonce. A same-selection re-key/re-parent can adopt the live
+    //    window; any target or provenance change necessarily remounts.
     useEffect(() => {
       let cancelled = false
       let controllerWaiter: (() => void) | null = null
@@ -197,13 +192,21 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
           window: live.window,
           slot,
           state: live.state,
-          targetId: live.targetId,
           dispose: () => closeAndRelease(live.windowId, slot),
         }
         if (refreshingRef.current) record.dispose()
         else hub.stashForAdopt(mountKey, record)
       }
 
+      /** A pre-ready failure must not leave an empty stage slot over the fallback UI. */
+      function crashAndRelease(error: unknown): void {
+        const slot = slotRef.current
+        slotRef.current = null
+        lastRectRef.current = null
+        slot?.release()
+        setStateSafe({ phase: 'crashed', windowId: windowIdRef.current ?? undefined, error })
+      }
+
       // Adopt a live window a just-unmounted same-source host left behind.
       if (!wasRefresh) {
         const adopted = hub.takeAdopt(mountKey)
@@ -214,9 +217,7 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
             windowId: adopted.windowId,
             window: adopted.window,
             state: adopted.state,
-            targetId: adopted.targetId,
           }
-          lastTargetRef.current = adopted.targetId
           hub.registry.upsert(adopted.windowId, adopted.window, adopted.state)
           lastRectRef.current = null
           measure() // reposition the surviving slot onto this host's anchor
@@ -225,33 +226,37 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
         }
       }
 
-      async function mountWith(handshake: 'shell' | 'none', downgraded: boolean): Promise<void> {
+      async function mountView(): Promise<void> {
         const p = propsRef.current
-        let resolved
+        let sandbox: SandboxProfile | null | undefined
         try {
-          resolved = await resolveSource(shell.kernel, sourceOf(p))
+          sandbox = typeof p.sandbox === 'function' ? p.sandbox(p.view) : p.sandbox
         } catch (err) {
-          // No window yet (source resolution failed) — windowId honestly absent.
-          if (!cancelled) setStateSafe({ phase: 'crashed', error: err })
+          if (!cancelled) crashAndRelease(err)
           return
         }
-        if (cancelled) return
-
-        const usedHandshake = handshake === 'none' ? 'none' : resolved.handshake
-        const deliveredTarget = refToId(p.node)
         const params: MountParams = {
           host: slotRef.current!.element,
-          url: resolved.url,
-          functionId: resolved.functionId,
-          capabilities: { intents: p.capabilities?.intents ?? [] },
-          targetNodeId: deliveredTarget,
-          sandbox: p.sandbox,
-          handshake: usedHandshake,
+          view: p.view,
+          capabilities: p.capabilities ?? {
+            version: 1,
+            navigation: {},
+            actions: {},
+            browser: {},
+            access: {},
+          },
+          sandbox,
           credential: p.credential,
+          ...(p.handshakeTimeoutMs === undefined
+            ? {}
+            : { handshakeTimeoutMs: p.handshakeTimeoutMs }),
+          ...(p.delegationTtlSeconds === undefined
+            ? {}
+            : { delegationTtlSeconds: p.delegationTtlSeconds }),
         }
 
         try {
-          const win = await shell.mount(params)
+          const win = await shell.openView(params)
           // A StrictMode cleanup (or refresh) fired before mount resolved: adopt
           // then immediately close so no orphan window survives.
           if (cancelled) {
@@ -259,25 +264,17 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
             return
           }
           windowIdRef.current = win.windowId
-          lastTargetRef.current = deliveredTarget
-          const ready: WindowState = downgraded
-            ? { phase: 'ready', windowId: win.windowId, downgraded: true }
-            : { phase: 'ready', windowId: win.windowId }
+          const ready: WindowState = { phase: 'ready', windowId: win.windowId }
           liveRef.current = {
             windowId: win.windowId,
             window: win.window,
             state: ready,
-            targetId: deliveredTarget,
           }
           hub.registry.upsert(win.windowId, win.window, ready)
           setStateSafe(ready)
         } catch (err) {
           if (cancelled) return
-          if (usedHandshake === 'shell' && isFallbackableHandshakeError(err)) {
-            await mountWith('none', true)
-            return
-          }
-          setStateSafe({ phase: 'crashed', windowId: windowIdRef.current ?? undefined, error: err })
+          crashAndRelease(err)
         }
       }
 
@@ -288,7 +285,7 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
         lastRectRef.current = null
         measure()
         setStateSafe(MOUNTING)
-        void mountWith('shell', false)
+        void mountView()
       }
 
       const existing = hub.getController()
@@ -303,15 +300,6 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [hub, shell, mountKey, refreshNonce])
 
-    // ── Retarget: a node change after ready hot-swaps via setTarget (no remount).
-    useEffect(() => {
-      if (state.phase !== 'ready') return
-      if (targetId === lastTargetRef.current) return
-      lastTargetRef.current = targetId
-      if (targetId === undefined) return
-      sendSetTarget(shell, state.windowId, targetId)
-    }, [shell, state, targetId])
-
     // ── Placement observers: reposition on resize/scroll/anchor-resize.
     useLayoutEffect(() => {
       measure()
@@ -340,8 +328,3 @@ export const ViewHost = forwardRef<ViewHostHandle, ViewHostProps>(
     )
   },
 )
-
-/** Narrow props back to the bare `ViewSource` discriminated union. */
-function sourceOf(props: ViewHostProps): ViewSource {
-  return 'url' in props ? { url: props.url } : { view: props.view }
-}

package/src/window/hub.ts

@@ -34,6 +34,8 @@ export interface WindowRegistry {
   upsert(windowId: string, window: Window, state: WindowState): void
   patch(windowId: string, state: WindowState): void
   remove(windowId: string): void
+  /** Shell writes: replace host and imperatively mounted windows from authoritative snapshots. */
+  sync(windows: ReadonlyMap<string, Window>): void
 }
 
 const NO_WINDOW: WindowView = { phase: 'closed', windowId: '', window: null }
@@ -98,7 +100,36 @@ function createWindowRegistry(): WindowRegistry {
       if (!entries.delete(windowId)) return
       invalidate()
     },
+
+    sync(windows) {
+      let changed = false
+      for (const windowId of entries.keys()) {
+        if (!windows.has(windowId)) {
+          entries.delete(windowId)
+          changed = true
+        }
+      }
+      for (const [windowId, window] of windows) {
+        const current = entries.get(windowId)
+        if (current?.window === window) continue
+        entries.set(windowId, {
+          window,
+          state: current?.state ?? phaseFor(window),
+        })
+        changed = true
+      }
+      if (changed) invalidate()
+    },
+  }
+}
+
+function phaseFor(window: Window): WindowState {
+  if (window.state === 'opening') return { phase: 'mounting' }
+  if (window.state === 'failed') {
+    return { phase: 'crashed', windowId: window.windowId }
   }
+  if (window.state === 'closed') return { phase: 'closed', windowId: window.windowId }
+  return { phase: 'ready', windowId: window.windowId }
 }
 
 // ── Per-shell hub ────────────────────────────────────────────────────────────
@@ -151,6 +182,8 @@ export function getStageHub(shell: Shell): StageHub {
       return adopt.take(key)
     },
   }
+  registry.sync(shell.windows)
+  shell.onWindowChange(() => registry.sync(shell.windows))
   HUBS.set(shell, hub)
   return hub
 }

package/src/window/index.ts

@@ -1,17 +1,17 @@
 // window — API §10. ViewStage/ViewHost (the physical iframe-slot layer + a host
-// that projects placement into a slot), the reactive window hooks, the child-side
+// that projects stage geometry into a slot), the reactive window hooks, the child-side
 // target-node + close-guard, and the (G5) view-resolution hook.
 export { ViewStage } from './stage.js'
 export { ViewHost } from './host.js'
-export type { ViewHostProps, ViewHostHandle } from './host.js'
+export type { SandboxPolicy, ViewHostProps, ViewHostHandle } from './host.js'
 export { useWindows, useWindowList } from './hooks/windows.hook.js'
 export type { WindowListEntry } from './hooks/windows.hook.js'
 export { useWindow } from './hooks/window.hook.js'
 export type { WindowView } from './hub.js'
 export { useViewsFor } from './hooks/views-for.hook.js'
 export type { ViewsForResult } from './hooks/views-for.hook.js'
-export { useTargetNode } from './hooks/target-node.hook.js'
+export { useTargetNode, useTargetPath } from './hooks/target-node.hook.js'
 export { useCloseGuard } from './hooks/close-guard.hook.js'
 export type { CloseGuard, CloseVerdict } from './hooks/close-guard.hook.js'
-export type { ViewDescriptor, ViewSource, Node } from './lifecycle/mount.js'
 export type { WindowState } from './lifecycle/states.js'
+export type { ResolvedView } from '@astrale-os/shell'

package/src/window/lifecycle/mount.ts

@@ -1,164 +1,19 @@
-import type { NodeRefInput } from '@astrale-os/kernel-client'
-/**
- * Mount orchestration (API §10) — resolve a `ViewSource` to something `shell.mount`
- * accepts (url + handshake + functionId), the stable remount key, the delivered
- * target id, the handshake-fallback predicate, and the parent→child setTarget
- * hot-swap. A one-call `View.resolve` kernel contract does not exist yet — the
- * bare-ref path is the honest subset, G5.
- */
-import type { KernelClient, Shell } from '@astrale-os/shell'
-
-/** A live graph node, derived from the shell kernel read surface (G8 seam). */
-export type Node = NonNullable<Awaited<ReturnType<KernelClient['get']>>>
-
-/** A View function resolved to something mountable (url + optional handshake). */
-export interface ViewDescriptor {
-  readonly id: string
-  readonly path: string
-  readonly url?: string
-  readonly handshake?: string
-}
-
-/**
- * What a `ViewHost` mounts:
- *  - `{ view }` — a View function (descriptor or ref), resolved to url + handshake.
- *  - `{ url }`  — a handshake-less hosted view; mounts immediately (no 5s wait).
- */
-export type ViewSource = { readonly view: NodeRefInput | ViewDescriptor } | { readonly url: string }
-
-export interface ResolvedSource {
-  readonly url: string
-  readonly handshake: 'shell' | 'none'
-  readonly functionId: string
-}
-
-function isViewDescriptor(view: NodeRefInput | ViewDescriptor): view is ViewDescriptor {
-  return typeof view === 'object' && view !== null && 'id' in view && 'path' in view
-}
-
-/** Last path segment or host, alnum-only — a stable-ish functionId from a url. */
-function slugOfUrl(url: string): string {
-  const trimmed = url.replace(/[#?].*$/, '').replace(/\/+$/, '')
-  const tail = trimmed.split('/').filter(Boolean).pop() ?? 'view'
-  return tail.replace(/[^a-z0-9]/gi, '').slice(-32) || 'view'
-}
-
-/** A ref addressable by the kernel read surface (`get`). `@<id>` for bare ids. */
-function toPath(ref: NodeRefInput): string {
-  if (typeof ref === 'string') {
-    return ref.startsWith('/') || ref.startsWith('@') ? ref : `@${ref}`
-  }
-  const obj = ref as { id?: string; path?: { raw?: string } }
-  if (obj.path?.raw !== undefined) return obj.path.raw
-  if (obj.id !== undefined) return `@${obj.id}`
-  throw new Error('ViewHost: unresolvable view ref')
-}
-
-async function resolveViewRef(
-  kernel: KernelClient,
-  ref: NodeRefInput,
-  handshakeHint?: string,
-): Promise<ResolvedSource> {
-  const node = await kernel.get(toPath(ref))
-  if (node === null) throw new Error(`ViewHost: view not found (${toPath(ref)})`)
-  const props = (node as { id?: string; props?: Record<string, unknown> }).props ?? {}
-  const url = viewUrl(props)
-  if (typeof url !== 'string' || url.length === 0) {
-    throw new Error('ViewHost: resolved view has no url')
-  }
-  const handshake = normalizeHandshake(handshakeHint ?? props.handshake)
-  const id = (node as { id?: string }).id ?? slugOfUrl(url)
-  return { url, handshake, functionId: id }
-}
-
-/** Resolve both the legacy flat url and the canonical Function binding. */
-function viewUrl(props: Record<string, unknown>): string | undefined {
-  if (typeof props.url === 'string' && props.url.length > 0) return props.url
-
-  const direct = remoteUrlOf(props.binding)
-  if (direct !== undefined) return direct
-
-  // Raw graph props can be keyed by the property's canonical graph key rather
-  // than its local slug. The binding value remains self-describing.
-  for (const value of Object.values(props)) {
-    const remoteUrl = remoteUrlOf(value)
-    if (remoteUrl !== undefined) return remoteUrl
-  }
-  return undefined
-}
-
-function remoteUrlOf(value: unknown): string | undefined {
-  let binding = value
-  if (typeof binding === 'string') {
-    try {
-      binding = JSON.parse(binding)
-    } catch {
-      return undefined
-    }
-  }
-  if (binding === null || typeof binding !== 'object') return undefined
-  const remoteUrl = (binding as { remoteUrl?: unknown }).remoteUrl
-  return typeof remoteUrl === 'string' && remoteUrl.length > 0 ? remoteUrl : undefined
-}
-
-function normalizeHandshake(value: unknown): 'shell' | 'none' {
-  return value === 'none' ? 'none' : 'shell'
-}
-
-/** Resolve a source; may hit the kernel for a bare/urless View ref (G5). */
-export async function resolveSource(
-  kernel: KernelClient,
-  source: ViewSource,
-): Promise<ResolvedSource> {
-  if ('url' in source) {
-    return { url: source.url, handshake: 'none', functionId: slugOfUrl(source.url) }
-  }
-  const view = source.view
-  if (isViewDescriptor(view)) {
-    if (view.url !== undefined && view.url.length > 0) {
-      return {
-        url: view.url,
-        handshake: normalizeHandshake(view.handshake),
-        functionId: view.id,
-      }
-    }
-    return resolveViewRef(kernel, view.id, view.handshake)
-  }
-  return resolveViewRef(kernel, view)
-}
-
-/** A stable remount key: the same source identity must not remount. */
-export function sourceKey(source: ViewSource): string {
-  if ('url' in source) return `url:${source.url}`
-  const view = source.view
-  if (isViewDescriptor(view)) return `view:${view.id}:${view.url ?? ''}:${view.handshake ?? ''}`
-  if (typeof view === 'string') return `ref:${view}`
-  const obj = view as { id?: string; path?: { raw?: string } }
-  return `ref:${obj.id ?? obj.path?.raw ?? '?'}`
-}
-
-/** The bare node id delivered as `targetNodeId` at mount / retarget. */
-export function refToId(ref: NodeRefInput | undefined): string | undefined {
-  if (ref === undefined) return undefined
-  if (typeof ref === 'string') return ref.startsWith('@') ? ref.slice(1) : ref
-  const obj = ref as { id?: string }
-  return obj.id
-}
+import type { ResolvedView } from '@astrale-os/shell'
 
 /**
- * Fallbackable = the view didn't speak the shell protocol (timeout/failed), not a
- * security refusal (origin mismatch) — only the former downgrades to plain.
+ * Stable identity for one target-bound, provenance-complete View route.
+ * A change to any routing or semantic witness forces a fresh mount; an old
+ * iframe and credential can never be adopted under a different route.
  */
-export function isFallbackableHandshakeError(err: unknown): boolean {
-  const code = (err as { code?: unknown } | null)?.code
-  return code === 'HANDSHAKE_TIMEOUT' || code === 'HANDSHAKE_FAILED'
-}
-
-/** Parent → child hot-swap of the target node (no remount) — API §10 setTarget. */
-export function sendSetTarget(shell: Shell, windowId: string, nodeId: string): void {
-  shell.children.send(windowId, {
-    type: 'intent',
-    version: 1,
-    envelope: { name: 'setTarget', payload: { nodeId }, sender: { windowId: '<parent>' } },
-  })
+export function viewMountKey(view: ResolvedView): string {
+  const { route, target } = view
+  return [
+    target,
+    route.key,
+    route.href,
+    route.handshake,
+    route.issuer,
+    route.etag,
+    route.revision,
+  ].join('\u0000')
 }

package/src/window/lifecycle/states.ts

@@ -8,16 +8,12 @@
 /**
  * Lifecycle of a hosted view as the React face observes it (API §10).
  *
- * `ready.downgraded` marks a mount that fell back to a plain iframe after a
- * fallbackable handshake error. It rides here (not on the shell `Window`) until
- * the shell `Window` grows a first-class flag — flagged in the module report.
- *
  * `crashed.windowId` is OPTIONAL: a crash before a window exists (a session-open
  * failure, a pre-mount source-resolution failure) has no id to report — the type
  * says so rather than carrying a placeholder `''`.
  */
 export type WindowState =
   | { readonly phase: 'mounting' }
-  | { readonly phase: 'ready'; readonly windowId: string; readonly downgraded?: boolean }
+  | { readonly phase: 'ready'; readonly windowId: string }
   | { readonly phase: 'crashed'; readonly windowId?: string; readonly error?: unknown }
   | { readonly phase: 'closed'; readonly windowId: string; readonly refusal?: string }

package/src/window/stage.tsx

@@ -23,6 +23,7 @@ const STAGE_STYLE: CSSProperties = {
   left: 0,
   right: 0,
   bottom: 0,
+  zIndex: 20,
   pointerEvents: 'none',
 }
 

package/dist/application/roles.hook.d.ts

@@ -1,7 +0,0 @@
-import type { RoleNode } from '@astrale-os/shell';
-import type { ReadState } from '../graph/memory/read/envelope.js';
-export interface RolesResult extends ReadState {
-    readonly roles: readonly RoleNode[];
-}
-export declare function useRoles(): RolesResult;
-//# sourceMappingURL=roles.hook.d.ts.map

package/dist/application/roles.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"roles.hook.d.ts","sourceRoot":"","sources":["../../src/application/roles.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAQjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAQjE,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;CACpC;AAED,wBAAgB,QAAQ,IAAI,WAAW,CAoBtC"}

package/dist/application/roles.hook.js

@@ -1,23 +0,0 @@
-/**
- * useRoles (API §12.2) — the roles self holds (`has_role` out-edges), over the
- * async OS namespace (one-shot today, §12 flag).
- */
-import { useMemo } from 'react';
-import { useAsyncResource } from '../graph/async.js';
-import { useShell } from '../session/shell.hook.js';
-import { isOsPlaneAvailable } from './user/user.store.js';
-const NO_ROLES = [];
-export function useRoles() {
-    const shell = useShell();
-    // OS plane unavailable (§12.2) → idle: no roles read.
-    const available = isOsPlaneAvailable(shell);
-    const res = useAsyncResource(available ? () => shell.user.roles() : null, NO_ROLES, [shell, available]);
-    return useMemo(() => ({
-        roles: res.data,
-        pending: res.pending,
-        error: res.error,
-        live: false,
-        seq: 0,
-        refetch: res.refetch,
-    }), [res]);
-}

package/dist/graph/memory/base.d.ts

@@ -1,21 +0,0 @@
-import type { GraphMemory, MemoryEvent } from '@astrale-os/kernel-client/store';
-/**
- * The base memory (API §5.4). One `GraphMemory` per live Shell — the partial
- * client copy of the graph every graph/schema/nav hook reads through, so they all
- * share one cache, one dedupe, one optimistic overlay. Derived from `shell.kernel`
- * and memoized on the Shell object. Its `onError` fans out through a per-Shell
- * sink the provider registers, so warm-refresh failures and rolled-back mutations
- * reach the provider's `onError` channel (§2).
- */
-import type { Shell } from '@astrale-os/shell';
-/** Register (or clear) the provider's memory-event bridge for a Shell. */
-export declare function setMemoryErrorSink(shell: Shell, sink: ((event: MemoryEvent) => void) | null): void;
-/**
- * The base (default-scope) memory for a Shell — the SAME instance every graph/
- * schema/nav hook reads through `useMemory`, so the provider can seat it in
- * `GraphContext` (selection's liveness source) without minting a rival copy.
- * Its `onError` fans out through the per-Shell sink so warm-refresh failures and
- * rolled-back mutations reach `ShellProvider`'s `onError` channel (§2).
- */
-export declare function baseMemoryFor(shell: Shell): GraphMemory;
-//# sourceMappingURL=base.d.ts.map

package/dist/graph/memory/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/graph/memory/base.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAC/E;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAc9C,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,IAAI,GAC1C,IAAI,CAGN;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,CASvD"}

package/dist/graph/memory/base.js

@@ -1,33 +0,0 @@
-import { createMemory } from '@astrale-os/kernel-client/store';
-/** One memory per Shell reference — shared by every hook under that provider. */
-const memoryByShell = new WeakMap();
-/**
- * Per-Shell error sink (API §2/§8). The provider registers a bridge here; the
- * memory emits refresh/mutation/divergence events through it, read lazily at
- * emit time so registration order doesn't matter. Cleared on provider unmount.
- */
-const errorSinks = new WeakMap();
-/** Register (or clear) the provider's memory-event bridge for a Shell. */
-export function setMemoryErrorSink(shell, sink) {
-    if (sink === null)
-        errorSinks.delete(shell);
-    else
-        errorSinks.set(shell, sink);
-}
-/**
- * The base (default-scope) memory for a Shell — the SAME instance every graph/
- * schema/nav hook reads through `useMemory`, so the provider can seat it in
- * `GraphContext` (selection's liveness source) without minting a rival copy.
- * Its `onError` fans out through the per-Shell sink so warm-refresh failures and
- * rolled-back mutations reach `ShellProvider`'s `onError` channel (§2).
- */
-export function baseMemoryFor(shell) {
-    let memory = memoryByShell.get(shell);
-    if (memory === undefined) {
-        memory = createMemory(shell.kernel, {
-            onError: (event) => errorSinks.get(shell)?.(event),
-        });
-        memoryByShell.set(shell, memory);
-    }
-    return memory;
-}

package/dist/graph/memory/read/read.d.ts

@@ -1,9 +0,0 @@
-import type { ShapeInput } from '@astrale-os/kernel-client/store';
-import type { CoreReadOptions, RawRead } from './envelope.js';
-/**
- * Subscribe to a memory shape and project it. `null`/`undefined` shape → idle.
- * Cold + `suspend` (default) throws the cold-shape promise; `suspend:false`
- * returns empty-pending; `keepPrevious` returns the last data while confirming.
- */
-export declare function useRead(shape: ShapeInput | null | undefined, opts?: CoreReadOptions): RawRead;
-//# sourceMappingURL=read.d.ts.map

package/dist/graph/memory/read/read.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../../src/graph/memory/read/read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,UAAU,EACX,MAAM,iCAAiC,CAAA;AAYxC,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAiC7D;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAgD7F"}