@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/src/project/vcs-branch-watcher.ts

@@ -0,0 +1,81 @@
+import path from "path"
+
+export namespace VcsBranchWatcher {
+  export interface Watcher {
+    start(): Promise<string | undefined>
+    current(): string | undefined
+    notify(file: string): void
+    idle(): Promise<void>
+    dispose(): Promise<void>
+  }
+
+  export function create(input: {
+    debounceMs: number
+    resolve: () => Promise<string | undefined>
+    onChange: (branch: string | undefined, previous: string | undefined) => Promise<void> | void
+  }): Watcher {
+    let branch: string | undefined
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let inFlight: Promise<void> | undefined
+    let refreshPending = false
+    let disposed = false
+    const idleWaiters = new Set<() => void>()
+
+    const settled = () => !timer && !inFlight
+    const resolveIdle = () => {
+      if (!settled()) return
+      for (const resolve of idleWaiters) resolve()
+      idleWaiters.clear()
+    }
+
+    const refresh = () => {
+      if (disposed || inFlight) return
+      inFlight = Promise.resolve()
+        .then(async () => {
+          while (!disposed && refreshPending) {
+            refreshPending = false
+            const previous = branch
+            const next = await input.resolve()
+            branch = next
+            if (next !== previous) await input.onChange(next, previous)
+          }
+        })
+        .finally(() => {
+          inFlight = undefined
+          if (!disposed && refreshPending) refresh()
+          resolveIdle()
+        })
+    }
+
+    return {
+      async start() {
+        branch = await input.resolve()
+        return branch
+      },
+      current() {
+        return branch
+      },
+      notify(file) {
+        if (disposed || path.basename(file) !== "HEAD") return
+        refreshPending = true
+        if (timer || inFlight) return
+        timer = setTimeout(() => {
+          timer = undefined
+          refresh()
+        }, input.debounceMs)
+      },
+      idle() {
+        if (settled()) return Promise.resolve()
+        return new Promise<void>((resolve) => idleWaiters.add(resolve))
+      },
+      async dispose() {
+        disposed = true
+        if (timer) clearTimeout(timer)
+        refreshPending = false
+        timer = undefined
+        await inFlight
+        resolveIdle()
+      },
+    }
+  }
+}

package/src/project/vcs.ts

@@ -0,0 +1,124 @@
+import { WorkspaceEvents } from "@ericsanchezok/synergy-harness/workspace/events"
+import { AsyncLocalStorage } from "node:async_hooks"
+import { EnvironmentResources } from "@ericsanchezok/synergy-harness/environment/resources"
+import { WorkspaceCatalog } from "@ericsanchezok/synergy-harness/workspace"
+import { BusEvent } from "@ericsanchezok/synergy-harness/bus/bus-event"
+import { $ } from "bun"
+import path from "path"
+import { z } from "zod"
+import { Log } from "@ericsanchezok/synergy-harness/util/log"
+import { WorkspaceState } from "@ericsanchezok/synergy-harness/workspace/state"
+import { FileWatcher } from "@ericsanchezok/synergy-local-runtime/file/watcher"
+import { Filesystem } from "@ericsanchezok/synergy-harness/util/filesystem"
+import { VcsBranchWatcher } from "./vcs-branch-watcher"
+import { FileView } from "@ericsanchezok/synergy-local-runtime/file/view"
+import { WorktreeProcess } from "@ericsanchezok/synergy-local-runtime/workspace/process"
+
+const log = Log.create({ service: "vcs" })
+
+export namespace Vcs {
+  export const Event = {
+    BranchUpdated: BusEvent.define(
+      "vcs.branch.updated",
+      z.object({
+        ...WorkspaceEvents.Fields,
+        branch: z.string().optional(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      branch: z.string(),
+    })
+    .meta({
+      ref: "VcsInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  async function currentBranch() {
+    const query = async () => {
+      const result = await WorktreeProcess.run({
+        command: ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        directory: FileView.directory(),
+        roots: [],
+        metadata: true,
+        env: { GIT_OPTIONAL_LOCKS: "0" },
+      })
+      return result.exitCode === 0 ? result.stdout.toString().trim() : undefined
+    }
+    try {
+      if (FileView.native()) return await query()
+      const owner = WorkspaceState.current()!
+      const workspace = await WorkspaceCatalog.get(owner.id!, owner.scopeID)
+      if (workspace.binding.generation !== owner.generation || workspace.activeMount?.state !== "active") return
+      await using resources = await EnvironmentResources.resolve({
+        scopeID: owner.scopeID,
+        workspaceID: owner.id,
+        workspaceGeneration: owner.generation,
+        needs: { workspace: true },
+      })
+      return await EnvironmentResources.provide(resources, `vcs:${crypto.randomUUID()}`, query)
+    } catch (error) {
+      log.debug("branch unavailable", { error })
+      return undefined
+    }
+  }
+
+  const state = WorkspaceState.create(
+    async () => {
+      const watcher = VcsBranchWatcher.create({
+        debounceMs: 50,
+        resolve: AsyncLocalStorage.bind(currentBranch),
+        onChange: (branch, previous) => {
+          log.info("branch changed", { from: previous, to: branch })
+          WorkspaceEvents.publish(Event.BranchUpdated, { branch })
+        },
+      })
+      const current = await watcher.start()
+      log.info("initialized", { branch: current })
+
+      const unsubscribe = WorkspaceEvents.subscribe(FileWatcher.Event.Updated, (event) => {
+        watcher.notify(event.properties.resync ? ".git/HEAD" : event.properties.file)
+      })
+
+      return {
+        branch: async () => watcher.current(),
+        unsubscribe,
+        watcher,
+      }
+    },
+    async (state) => {
+      state.unsubscribe?.()
+      await state.watcher?.dispose()
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  export async function branch() {
+    return await state().then((s) => s.branch())
+  }
+
+  export async function initIfNeeded(directory: string, options?: { searchParents?: boolean }) {
+    const gitDir = path.join(directory, ".git")
+    const stat = await Bun.file(gitDir)
+      .stat()
+      .catch(() => undefined)
+    if (stat) return false
+
+    if (options?.searchParents !== false) {
+      const matches = Filesystem.up({ targets: [".git"], start: directory })
+      const found = await matches.next().then((x) => x.value)
+      await matches.return()
+      if (found) return false
+    }
+
+    log.info("initializing git repository", { directory })
+    await $`git init`.cwd(directory).quiet()
+    await $`git commit --allow-empty -m "Initial commit"`.cwd(directory).quiet()
+    return true
+  }
+}

package/src/project/worktree-janitor.ts

@@ -0,0 +1,153 @@
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context"
+import type { Scope } from "@ericsanchezok/synergy-harness/scope"
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context"
+import { Log } from "@ericsanchezok/synergy-harness/util/log"
+import { readWorktreeConfig } from "@ericsanchezok/synergy-local-runtime/config-schema"
+import { ProjectWorktrees } from "./worktrees"
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree"
+
+const log = Log.create({ service: "worktree-janitor" })
+
+const DEFAULT_SWEEP_INTERVAL_HOURS = 6
+
+interface Schedule {
+  first: ReturnType<typeof setTimeout>
+  interval: ReturnType<typeof setInterval>
+}
+
+const runtimeState = RuntimeContext.state(() => ({
+  schedules: new Map<string, Schedule>(),
+  sweeping: new Map<string, Promise<void>>(),
+  rerunRequested: new Set<string>(),
+}))
+
+/**
+ * Background reaper for managed git worktrees.
+ *
+ * The first scan is scheduled with `setTimeout(0)` rather than awaited, so a
+ * slow or failing sweep never delays scope startup. Both timers are unref'd: a
+ * janitor must not be the reason the process stays alive. Sweeps are mutually
+ * exclusive per scope, because a tick that outlives its interval would
+ * otherwise let two sweeps race on the same worktree.
+ */
+export async function startWorktreeJanitor(scope: Scope.Project) {
+  const instanceState = runtimeState()
+
+  // The cap owner asks for a sweep after each creation; routing that request back
+  // here keeps one implementation of the timing, config, and mutual exclusion.
+  Worktree.setSweepRequester(requestScopeSweep)
+  if (!scope.local || instanceState.schedules.has(scope.id)) return
+  const config = await readWorktreeConfig().catch(() => undefined)
+  if (config?.janitor === false) {
+    log.info("worktree janitor disabled by config", { scopeID: scope.id })
+    return
+  }
+  const intervalMs = (config?.sweepIntervalHours ?? DEFAULT_SWEEP_INTERVAL_HOURS) * 60 * 60 * 1000
+  const trigger = () => requestScopeSweep(scope)
+  const first = setTimeout(trigger, 0)
+  first.unref()
+  const interval = setInterval(trigger, intervalMs)
+  interval.unref()
+  instanceState.schedules.set(scope.id, { first, interval })
+  log.info("worktree janitor scheduled", { scopeID: scope.id, intervalMs })
+}
+
+export async function stopWorktreeJanitor(scopeID: string) {
+  const instanceState = runtimeState()
+
+  const schedule = instanceState.schedules.get(scopeID)
+  if (schedule) {
+    clearTimeout(schedule.first)
+    clearInterval(schedule.interval)
+  }
+  instanceState.schedules.delete(scopeID)
+  instanceState.rerunRequested.delete(scopeID)
+  await instanceState.sweeping.get(scopeID)
+}
+
+/**
+ * Schedule a cap sweep for a scope without awaiting it.
+ *
+ * Called after a worktree is created, which is when the cap is most likely to be
+ * exceeded. It must never throw or block: creation has already succeeded, so a
+ * sweep that cannot converge must not surface as a creation failure. If a sweep
+ * is already running, one follow-up is queued rather than dropped — the running
+ * sweep may have read its inventory before this worktree existed.
+ */
+export function requestScopeSweep(scope: Scope.Project) {
+  const instanceState = runtimeState()
+
+  // Only a scope whose janitor actually started may sweep. The requester is
+  // installed process-wide by the first scope that starts one, so without this
+  // guard a creation in any other scope would run a background sweep it never
+  // opted into — cancelling registrations that scope is still using.
+  if (!scope.local || !instanceState.schedules.has(scope.id)) return
+  if (instanceState.sweeping.has(scope.id)) {
+    instanceState.rerunRequested.add(scope.id)
+    return
+  }
+  void sweep(scope)
+}
+
+function sweep(scope: Scope.Project): Promise<void> {
+  const instanceState = runtimeState()
+
+  const current = instanceState.sweeping.get(scope.id)
+  if (current) return current
+  if (!instanceState.schedules.has(scope.id)) return Promise.resolve()
+  const task = runSweep(scope).finally(() => {
+    const instanceState = runtimeState()
+
+    if (instanceState.sweeping.get(scope.id) === task) instanceState.sweeping.delete(scope.id)
+    if (instanceState.rerunRequested.delete(scope.id) && instanceState.schedules.has(scope.id)) void sweep(scope)
+  })
+  instanceState.sweeping.set(scope.id, task)
+  return task
+}
+
+async function runSweep(scope: Scope.Project) {
+  const instanceState = runtimeState()
+
+  try {
+    // Resolved per sweep so a config reload takes effect without a restart, and
+    // so a read failure falls back to the cap default rather than skipping.
+    const config = await readWorktreeConfig().catch(() => undefined)
+    if (config?.janitor === false || !instanceState.schedules.has(scope.id)) return
+    const report = await ScopeContext.provide({
+      scope,
+      workspace: null,
+      fn: async () => {
+        const { ids } = await ProjectWorktrees.sources(scope.id)
+        const results = await Promise.allSettled(
+          ids.map((id) => Worktree.withSource(id, () => Worktree.sweep({ maxManaged: config?.maxManaged }))),
+        )
+        const reports = results.flatMap((result, index) => {
+          if (result.status === "fulfilled") return [result.value]
+          log.warn("Worktree source sweep failed", { scopeID: scope.id, workspaceID: ids[index], error: result.reason })
+          return []
+        })
+        return {
+          scanned: reports.reduce((total, item) => total + item.scanned, 0),
+          maxManaged: config?.maxManaged,
+          removed: reports.flatMap((item) => item.removed),
+          reconciled: reports.flatMap((item) => item.reconciled),
+          skipped: reports.flatMap((item) => item.skipped),
+        }
+      },
+    })
+    // Reasons are reported rather than swallowed: a cap that cannot converge is
+    // the signal that worktrees are blocked on unpushed work, not a silent
+    // pile-up.
+    const blocked = report.skipped.map((item) => `${item.name}:${item.reason}`).join(", ")
+    log.info("worktree sweep complete", {
+      scopeID: scope.id,
+      scanned: report.scanned,
+      maxManaged: report.maxManaged,
+      removed: report.removed.length,
+      reconciled: report.reconciled.length,
+      blocked: blocked || "none",
+    })
+  } catch (error) {
+    log.warn("worktree sweep failed", { scopeID: scope.id, error })
+  }
+}

package/src/project/worktrees.ts

@@ -0,0 +1,110 @@
+import { WorkspaceCatalog } from "@ericsanchezok/synergy-harness/workspace"
+import { Worktree } from "@ericsanchezok/synergy-local-runtime/workspace/worktree"
+import { Log } from "@ericsanchezok/synergy-harness/util/log"
+import { ProjectDirectories } from "./directories"
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context"
+import { z } from "zod"
+import { Bus } from "@ericsanchezok/synergy-harness/bus"
+
+export namespace ProjectWorktrees {
+  const log = Log.create({ service: "project-worktrees" })
+  export const Inventory = z
+    .object({
+      items: Worktree.InventoryEntry.array(),
+      version: z.string(),
+      generatedAt: z.number(),
+      sync: z.object({ epoch: z.string(), seq: z.number().int().nonnegative() }),
+    })
+    .meta({ ref: "ProjectWorktreeInventory" })
+  export type Inventory = z.infer<typeof Inventory>
+  const inventoryCache = RuntimeContext.state(
+    () => new Map<string, { version: string; expires: number; pending: Promise<Inventory> }>(),
+  )
+
+  export async function sources(scopeID: string) {
+    const directories = await ProjectDirectories.get(scopeID)
+    const records = await WorkspaceCatalog.list(scopeID)
+    const ids = new Set(
+      directories.folders.filter((folder) => folder.available && folder.git).map((folder) => folder.workspaceID),
+    )
+    for (const tree of records) {
+      if (tree.type !== "git_worktree") continue
+      const source = records.find(
+        (item) => item.id === tree.metadata.sourceWorkspaceID || item.binding.path === tree.metadata.originalCheckout,
+      )
+      if (source) ids.add(source.id)
+    }
+    return { ids: [...ids], records, revision: directories.revision }
+  }
+
+  export async function list(scopeID: string): Promise<Worktree.Info[]> {
+    return collect(scopeID, () => Worktree.list())
+  }
+
+  export async function inventory(scopeID: string): Promise<Inventory> {
+    const sync = { epoch: Bus.epoch(), seq: Bus.currentSeq() }
+    const current = await sources(scopeID)
+    const version = new Bun.CryptoHasher("sha256")
+      .update(
+        JSON.stringify([
+          current.revision,
+          current.records.map((record) => [record.id, record.revision, record.binding.generation]),
+        ]),
+      )
+      .digest("hex")
+    const cache = inventoryCache()
+    const cached = cache.get(scopeID)
+    if (cached && cached.version === version && cached.expires > Date.now()) return cached.pending
+    const pending = collect(scopeID, () => Worktree.inventory(), current).then((items) => ({
+      items: items.map((item) => Worktree.InventoryEntry.parse(item)),
+      version,
+      generatedAt: Date.now(),
+      sync,
+    }))
+    const entry = { version, expires: Date.now() + 5_000, pending }
+    cache.set(scopeID, entry)
+    void pending.catch(() => {
+      if (cache.get(scopeID) === entry) cache.delete(scopeID)
+    })
+    return pending
+  }
+
+  async function collect(
+    scopeID: string,
+    read: () => Promise<Worktree.Info[]>,
+    source?: Awaited<ReturnType<typeof sources>>,
+  ): Promise<Worktree.Info[]> {
+    const { ids, records } = source ?? (await sources(scopeID))
+    const results = await Promise.allSettled(ids.map((id) => Worktree.withSource(id, read)))
+    const trees = new Map<string, Worktree.Info>()
+    for (const [index, result] of results.entries()) {
+      if (result.status === "rejected") {
+        log.warn("Worktree source unavailable", { scopeID, workspaceID: ids[index], error: result.reason })
+        continue
+      }
+      for (const tree of result.value) if (!tree.isMain) trees.set(tree.path, tree)
+    }
+    for (const record of records) {
+      if (
+        record.type !== "git_worktree" ||
+        record.lifecycle === "deleted" ||
+        !record.binding.path ||
+        trees.has(record.binding.path)
+      )
+        continue
+      trees.set(record.binding.path, {
+        id: String(record.metadata.worktreeID ?? record.id),
+        scopeID,
+        path: record.binding.path,
+        name: String(record.metadata.name ?? record.binding.path.split("/").at(-1)),
+        branch: typeof record.metadata.branch === "string" ? record.metadata.branch : undefined,
+        sourceWorkspaceID:
+          typeof record.metadata.sourceWorkspaceID === "string" ? record.metadata.sourceWorkspaceID : undefined,
+        sourceDirectory:
+          typeof record.metadata.originalCheckout === "string" ? record.metadata.originalCheckout : undefined,
+        stale: true,
+      })
+    }
+    return [...trees.values()]
+  }
+}

package/src/push/bridge.ts

@@ -0,0 +1,182 @@
+import { RuntimeContext } from "@ericsanchezok/synergy-harness/lifecycle/context"
+import { base64Encode } from "@ericsanchezok/synergy-util/encode"
+import { Bus } from "@ericsanchezok/synergy-harness/bus"
+import { Log } from "@ericsanchezok/synergy-harness/util/log"
+import { PermissionNext } from "@ericsanchezok/synergy-harness/permission/next"
+import { Question } from "@ericsanchezok/synergy-local-runtime/question"
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context"
+import { SessionEvent } from "@ericsanchezok/synergy-harness/session/event"
+import { SessionManager } from "@ericsanchezok/synergy-harness/session/manager"
+import type { Info as SessionInfo } from "@ericsanchezok/synergy-harness/session/types"
+import { PushService } from "./service"
+import type { PushTypes } from "./types"
+
+export namespace PushBridge {
+  const log = Log.create({ service: "push.bridge" })
+
+  const MAX_BODY_LENGTH = 200
+
+  const runtimeState = RuntimeContext.state(() => ({
+    inflight: new Set<Promise<unknown>>(),
+    disposeActive: undefined as (() => void) | undefined,
+  }))
+
+  /** Await all in-flight fan-outs (deterministic tests, graceful shutdown). */
+  export async function flush(): Promise<void> {
+    const instanceState = runtimeState()
+
+    while (instanceState.inflight.size > 0) await Promise.allSettled([...instanceState.inflight])
+  }
+
+  export function init(): () => void {
+    const instanceState = runtimeState()
+
+    if (instanceState.disposeActive) return instanceState.disposeActive
+
+    const publish = (payload: PushTypes.Payload) => {
+      const instanceState = runtimeState()
+
+      const task = PushService.send(payload).catch((error) => log.warn("push send failed", { error }))
+      instanceState.inflight.add(task)
+      void task.finally(() => {
+        const instanceState = runtimeState()
+        return instanceState.inflight.delete(task)
+      })
+    }
+
+    const truncate = (body: string): string =>
+      body.length > MAX_BODY_LENGTH ? body.slice(0, MAX_BODY_LENGTH - 1) + "…" : body
+
+    // Mirrors the Web app's notification-event.ts href contract: the scope
+    // token is "home" for the home scope, otherwise the scope directory.
+    const scopeToken = (session: SessionInfo): string =>
+      session.scope.type === "home" ? "home" : (session.scope.local?.directory ?? "home")
+
+    const sessionHref = (session: SessionInfo): string => `/${base64Encode(scopeToken(session))}/session/${session.id}`
+
+    const resolveSession = async (sessionID: string | undefined): Promise<SessionInfo | undefined> => {
+      if (!sessionID) return undefined
+      return SessionManager.getSession(sessionID).catch(() => undefined)
+    }
+
+    // Channel-endpoint sessions deliver through their own channel surface
+    // (outbound bridge / question cards); completion/error additionally skip
+    // child sessions to mirror the in-app notification rules.
+    const skip = (session: SessionInfo, category: "completion" | "error" | "input"): boolean => {
+      if (session.endpoint?.kind === "channel") return true
+      if (category !== "input" && session.parentID) return true
+      return false
+    }
+
+    const unsubscribers = [
+      Bus.subscribeGlobal(SessionEvent.Completion, (event) => {
+        const instanceState = runtimeState()
+
+        const task = (async () => {
+          const session = await resolveSession(event.properties.sessionID)
+          if (!session || skip(session, "completion")) return
+          publish({
+            title: "Response ready",
+            body: truncate(session.title),
+            href: sessionHref(session),
+            tag: `session-${session.id}`,
+            category: "completion",
+            badge: event.properties.unreadCount,
+          })
+        })().catch((error) => log.warn("completion push failed", { error }))
+        instanceState.inflight.add(task)
+        void task.finally(() => {
+          const instanceState = runtimeState()
+          return instanceState.inflight.delete(task)
+        })
+      }),
+      Bus.subscribeGlobal(SessionEvent.Error, (event) => {
+        const instanceState = runtimeState()
+
+        const task = (async () => {
+          const sessionID = event.properties.sessionID
+          if (!sessionID) {
+            // Truly global errors (no session context) fall back to the
+            // current scope root; unresolved session-scoped errors stay
+            // silent instead of leaking raw error text as a global push.
+            const scope = ScopeContext.current.scope
+            const directory = scope.type === "home" ? "home" : (scope.local?.directory ?? "home")
+            publish({
+              title: "Session error",
+              body: truncate(typeof event.properties.error === "string" ? event.properties.error : "Session error"),
+              href: `/${base64Encode(directory)}`,
+              tag: "session-global",
+              category: "error",
+            })
+            return
+          }
+          const session = await resolveSession(sessionID)
+          if (!session || skip(session, "error")) return
+          const error = event.properties.error
+          publish({
+            title: "Session error",
+            body: truncate(session.title ?? (typeof error === "string" ? error : "Session error")),
+            href: sessionHref(session),
+            tag: `session-${session.id}`,
+            category: "error",
+          })
+        })().catch((error) => log.warn("error push failed", { error }))
+        instanceState.inflight.add(task)
+        void task.finally(() => {
+          const instanceState = runtimeState()
+          return instanceState.inflight.delete(task)
+        })
+      }),
+      Bus.subscribeGlobal(Question.Event.Asked, (event) => {
+        const instanceState = runtimeState()
+
+        const task = (async () => {
+          const session = await resolveSession(event.properties.sessionID)
+          if (!session || skip(session, "input")) return
+          publish({
+            title: "Session needs your input",
+            body: truncate(session.title),
+            href: sessionHref(session),
+            tag: `input-${session.id}`,
+            category: "input",
+          })
+        })().catch((error) => log.warn("question push failed", { error }))
+        instanceState.inflight.add(task)
+        void task.finally(() => {
+          const instanceState = runtimeState()
+          return instanceState.inflight.delete(task)
+        })
+      }),
+      Bus.subscribeGlobal(PermissionNext.Event.Asked, (event) => {
+        const instanceState = runtimeState()
+
+        const task = (async () => {
+          const session = await resolveSession(event.properties.sessionID)
+          if (!session || skip(session, "input")) return
+          publish({
+            title: "Session needs your input",
+            body: truncate(session.title),
+            href: sessionHref(session),
+            tag: `input-${session.id}`,
+            category: "input",
+          })
+        })().catch((error) => log.warn("permission push failed", { error }))
+        instanceState.inflight.add(task)
+        void task.finally(() => {
+          const instanceState = runtimeState()
+          return instanceState.inflight.delete(task)
+        })
+      }),
+    ]
+
+    const dispose = () => {
+      const instanceState = runtimeState()
+
+      if (instanceState.disposeActive !== dispose) return
+      for (const unsubscribe of unsubscribers) unsubscribe()
+      instanceState.disposeActive = undefined
+    }
+    instanceState.disposeActive = dispose
+    return dispose
+  }
+}

package/src/push/index.ts

@@ -0,0 +1,4 @@
+export { PushTypes } from "./types"
+export { PushStore } from "./store"
+export { PushService } from "./service"
+export { PushBridge } from "./bridge"