One app.
Plugins all the way up.

import { defineApp } from "@kolu/surface-cordis-app"
import { web, mcp } from "@kolu/surface-cordis-app/plugins"
import { workspaceShell, inspector } from "@example/workspace-shell"
import { notes } from "./plugins/notes"

const domain = [notes]

export const app = defineApp({
  profiles: {
    web:      [...domain, workspaceShell, inspector, web({ port: 3000 }), mcp()],
    headless: [...domain, mcp()],
  },
})

await app.start({ profile: "web" })

import { Schema } from "effect"
import { defineSurface } from "@kolu/surface/define"

export const notesSurface = defineSurface({
  cells: {
    title: { schema: Schema.String, default: "Untitled" },
  },
})

import { definePlugin } from "@kolu/surface-cordis-app"
import { notesSurface } from "./wire"

export const notes = definePlugin({
  id: "notes",
  surface: notesSurface,

  server:  () => import("./server"),
  browser: () => import("./browser"),
})

import { defineServer } from "@kolu/surface-cordis-app/server"
import { makeNotesDeps } from "./store"

export default defineServer({
  // Effect<ImplementSurfaceDeps<typeof notesSurface>, Error, Scope>
  setup: makeNotesDeps,

  expose: {
    browser: { title: "resource" },
    mcp:     { title: "resource" },
  },
})

// Host: initialize → mount Surface → publish availability.
// Unload: withdraw → settle owned work → release the scope.

import { defineBrowser } from "@kolu/surface-cordis-app/browser"
import { Workspace } from "@example/workspace-shell/contracts"
import { NotesView } from "./NotesView"

export default defineBrowser({
  needs: { workspace: Workspace },

  mount({ client, workspace }) {
    // client is the plugin’s ready Surface client.
    return workspace.panel({
      id: "notes",
      title: "Notes",
      render: () => <NotesView client={client} />,
    })
  },
})

// panel() returns an owned disposer.
// No Workspace provider → this browser component waits.
// Notes’ server component has no Workspace dependency.

import { defineBrowser } from "@kolu/surface-cordis-app/browser"
import { Workspace } from "./contracts"
import { mountWorkspace } from "./ui"

export default defineBrowser({
  mount({ root, provide, own }) {
    const workspace = mountWorkspace(root)
    own(workspace.dispose)

    provide(Workspace, {
      panel: workspace.registerPanel,
    })
  },
})

// The bridge withdraws Workspace and joins dependent cleanup
// before disposing the workspace. Cordis owns dependency resolution.

await app.plugins.disable("notes")
// Its browser contribution, wire availability and MCP catalog retract.
// Unrelated plugins and their local UI state keep running.

await app.plugins.enable("notes")
// Fresh server activation; clients follow the new mount.
// Browser contribution activates after its dependencies are ready.

await app.plugins.disable("workspace-shell")
// Dependent UI contributions unload. Notes’ server stays running.

await app.stop()
// Join plugin cleanup, then close the host.