@ossy/app 1.40.3 → 3.0.2

package/runtime/page-runtime.js

@@ -1,7 +1,8 @@
 import { createElement } from 'react'
 import { pageIdToDocumentTitleKey, resolveMessage } from '@ossy/locale'
+import { Slot } from '@ossy/design-system'
 import { App } from '../src/shell/App.jsx'
-import { resolvePageSlots } from './resolve-app-slots.js'
+import { resolvePageSlots, CONTENT_SLOT_NAME } from './resolve-app-slots.js'
 
 /**
  * Dynamically imports each component bundle listed in `entries` and returns a
@@ -11,14 +12,17 @@ import { resolvePageSlots } from './resolve-app-slots.js'
  * skipped so a broken component never prevents the page from rendering.
  *
  * @param {Array<{ id: string, entry: string }>} entries
+ * @param {(entry: string) => string} [resolveEntry] — map manifest `/static/…` paths to
+ *   absolute `file://` URLs on the server; omit in the browser (paths resolve via HTTP).
  * @returns {Promise<Record<string, import('react').ComponentType>>}
  */
-export async function loadComponents (entries = []) {
+export async function loadComponents (entries = [], resolveEntry) {
   const map = {}
+  const resolve = typeof resolveEntry === 'function' ? resolveEntry : (entry) => entry
   await Promise.all(
     entries.map(async ({ id, entry }) => {
       try {
-        const mod = await import(entry)
+        const mod = await import(resolve(entry))
         if (mod && mod.default) map[id] = mod.default
       } catch {
         // silently skip broken component bundles
@@ -29,10 +33,10 @@ export async function loadComponents (entries = []) {
 }
 
 /**
- * Dynamically imports the app's single layout bundle. Layout components cannot
+ * Dynamically imports the layout bundle for the current page. Layout components cannot
  * be serialized into the bootstrap JSON (functions are stripped), so the server
- * passes `layoutEntry` and the client loads the same module here. When present,
- * every page is wrapped — route-specific chrome is decided inside the layout.
+ * passes `layoutEntry` and the client loads the same module here. Each page may
+ * reference a different layout id (resolved at build time per ADR 0012).
  *
  * @param {string | null | undefined} layoutEntry
  * @returns {Promise<import('react').ComponentType | null>}
@@ -76,20 +80,22 @@ function resolveDocumentTitle (metadata, props) {
   return metadata.title || props.documentTitle || ''
 }
 
-function buildTree ({ Component, Layout, metadata, props }) {
+/** Page body is registered on `app:content`; layouts only gate shell chrome around it. */
+function buildTree ({ Layout, metadata, props }) {
   const lang = props.language || props.defaultLanguage || 'en'
-  const pageEl = createElement(Component, props)
-  const contentEl = Layout ? createElement(Layout, props, pageEl) : pageEl
+  const contentEl = Layout
+    ? createElement(Layout, { shellSlots: props.layoutSlots ?? {}, ...props })
+    : createElement(Slot, { view: CONTENT_SLOT_NAME })
   return createElement(
     'html',
-    { lang },
+    { lang, style: { height: '100%' } },
     createElement(
       'head',
       null,
       createElement('meta', { charSet: 'utf-8' }),
       createElement('title', null, resolveDocumentTitle(metadata, props)),
     ),
-    createElement('body', null, createElement(App, props, contentEl)),
+    createElement('body', { style: { height: '100%', margin: 0 } }, createElement(App, props, contentEl)),
   )
 }
 
@@ -127,20 +133,26 @@ export function createPageEntry (pageModule, options = {}) {
       import('node:stream'),
     ])
 
-    const { Layout = null, componentEntries = [], layoutSlots = {}, ...pageProps } = props
-    const componentsById = await loadComponents(componentEntries)
+    const {
+      Layout = null,
+      componentEntries = [],
+      layoutSlots = {},
+      resolveComponentEntry,
+      ...pageProps
+    } = props
+    const componentsById = await loadComponents(componentEntries, resolveComponentEntry)
     const PageContent = (slotProps = {}) => createElement(Component, { ...pageProps, ...slotProps })
     const components = resolvePageSlots({
       layoutSlots,
       componentsById,
       pageComponent: PageContent,
     })
-    const tree = buildTree({ Component, Layout, metadata, props: { ...pageProps, components } })
+    const tree = buildTree({ Layout, metadata, props: { ...pageProps, components, layoutSlots } })
     const bootstrapUrl = toBootstrapUrl(entryUrl)
     const bootstrapModules = bootstrapUrl ? [bootstrapUrl] : []
     // Layout is a React component — JSON.stringify drops functions, so hydration
     // would render without the shell unless we pass the serializable entry URL.
-    const { Layout: _layout, ...bootstrapProps } = props
+    const { Layout: _layout, resolveComponentEntry: _resolveComponentEntry, ...bootstrapProps } = props
     const bootstrapScriptContent =
       'window.__OSSY__=' + escapeBootstrapJson(JSON.stringify(bootstrapProps ?? {}))
 
@@ -182,7 +194,11 @@ export function createPageEntry (pageModule, options = {}) {
         componentsById,
         pageComponent: PageContent,
       })
-      hydrateRoot(document, buildTree({ Component, Layout, metadata, props: { ...pageProps, components } }))
+      hydrateRoot(document, buildTree({
+        Layout,
+        metadata,
+        props: { ...pageProps, components, layoutSlots },
+      }))
     }).catch((err) => {
       if (typeof console !== 'undefined' && typeof console.error === 'function') {
         console.error('[@ossy/app][page-runtime] Hydration failed:', err)

package/runtime/resolve-app-slots.js

@@ -1,10 +1,15 @@
+import { createElement } from 'react'
+import { coerceShellSlotSpec, shellSlotViewId } from './merge-shell-slots.js'
+
 /** Canonical app chrome slot names (namespaced). App layout maps chrome only — not content. */
 export const APP_SLOT_NAMES = [
+  'app:head',
   'app:header',
   'app:sidebar',
   'app:toolbar',
   'app:notifications',
   'app:system-messages',
+  'app:footer',
 ]
 
 /** Platform-owned slot filled with the current route page component. */
@@ -14,14 +19,29 @@ const APP_SLOT_PREFIX = 'app'
 
 /** Bare app region → namespaced key (legacy fallback for app components only). */
 const BARE_APP_REGION = {
+  head: 'app:head',
   header: 'app:header',
   sidebar: 'app:sidebar',
   toolbar: 'app:toolbar',
   notifications: 'app:notifications',
   'system-messages': 'app:system-messages',
+  footer: 'app:footer',
   content: CONTENT_SLOT_NAME,
 }
 
+/**
+ * @param {import('react').ComponentType<any>} Component
+ * @param {Record<string, unknown>} defaultProps
+ * @returns {import('react').ComponentType<any>}
+ */
+function withShellSlotProps (Component, defaultProps) {
+  function ShellSlotTarget (props) {
+    return createElement(Component, { ...defaultProps, ...props })
+  }
+  ShellSlotTarget.displayName = `ShellSlot(${Component.displayName || Component.name || 'Component'})`
+  return ShellSlotTarget
+}
+
 /**
  * Normalize a slot map key to the canonical namespaced form when it is a bare app region.
  *
@@ -34,10 +54,10 @@ export function normalizeAppSlotName (slotName) {
 }
 
 /**
- * Build `Record<slotName, Component>` from the app layout's static `slots` map
- * (`slotName → componentId`) and components loaded by `metadata.id`.
+ * Build `Record<slotName, Component>` from merged shell slot specs
+ * (`slotName → component id + default props`) and components loaded by `metadata.id`.
  *
- * @param {Record<string, string> | null | undefined} layoutSlotsMap
+ * @param {Record<string, string | null | import('./merge-shell-slots.js').ShellSlotSpec | undefined> | null | undefined} layoutSlotsMap
  * @param {Record<string, import('react').ComponentType>} componentsById
  * @returns {Record<string, import('react').ComponentType>}
  */
@@ -46,16 +66,33 @@ export function resolveAppSlots (layoutSlotsMap, componentsById) {
   const resolved = {}
 
   const map = layoutSlotsMap && typeof layoutSlotsMap === 'object' ? layoutSlotsMap : {}
-  for (const [rawSlot, componentId] of Object.entries(map)) {
+  for (const [rawSlot, rawSpec] of Object.entries(map)) {
     const slotName = normalizeAppSlotName(rawSlot)
-    const id = typeof componentId === 'string' ? componentId.trim() : ''
-    if (!slotName || !id || slotName === CONTENT_SLOT_NAME) continue
-    const Component = componentsById[id]
-    if (Component) resolved[slotName] = Component
+    if (!slotName || slotName === CONTENT_SLOT_NAME) continue
+
+    const spec = coerceShellSlotSpec(rawSpec) ?? (
+      rawSpec && typeof rawSpec === 'object' && !Array.isArray(rawSpec) ? rawSpec : undefined
+    )
+
+    if (spec?.view === null) {
+      resolved[slotName] = null
+      continue
+    }
+
+    const componentId = shellSlotViewId(spec ?? rawSpec)
+    if (!componentId) continue
+
+    const Component = componentsById[componentId]
+    if (!Component) continue
+
+    const defaultProps = spec?.props ?? {}
+    resolved[slotName] = Object.keys(defaultProps).length > 0
+      ? withShellSlotProps(Component, defaultProps)
+      : Component
   }
 
   for (const slotName of APP_SLOT_NAMES) {
-    if (resolved[slotName]) continue
+    if (slotName in resolved) continue
     if (componentsById[slotName]) {
       resolved[slotName] = componentsById[slotName]
       continue
@@ -69,10 +106,10 @@ export function resolveAppSlots (layoutSlotsMap, componentsById) {
 
 /**
  * Full provider slot map for a page request: app chrome and page content.
- * Feature components register at canonical ADR 0006 ids (`@ossy/…/view|form/…`).
+ * Feature components register at canonical ADR 0006 ids (`@ossy/…/view|form|…`).
  *
  * @param {{
- *   layoutSlots?: Record<string, string> | null,
+ *   layoutSlots?: Record<string, string | null | import('./merge-shell-slots.js').ShellSlotSpec> | null,
  *   componentsById?: Record<string, import('react').ComponentType>,
  *   pageComponent?: import('react').ComponentType | null,
  * }} options

package/src/en.translations.json

@@ -0,0 +1,8 @@
+{
+  "app.shell.sidebar.expand": "Expand sidebar",
+  "app.shell.sidebar.collapse": "Collapse sidebar",
+  "app.shell.header.languagePicker": "Language",
+  "app.shell.footer.languages": "Languages",
+  "app.shell.header.themeSwitch": "{theme} theme. Switch theme.",
+  "app.shell.header.profile": "Profile"
+}

package/src/manifest/build-actions-schema.js

@@ -1,36 +1 @@
-import { buildCapabilities, capabilitiesToActionsSchema } from './build-capabilities.js'
-import { taskIdFromActionId } from '@ossy/schema'
-
-/**
- * @param {Array<{ id: string, access?: string, package?: string }>} actions
- * @param {{ schemas?: object[], tasks?: object[], taskCatalog?: object[], taskGraphEdges?: object[], generatedAt?: string }} [options]
- * @returns {{ version: number, generatedAt: string, actions: Array<object> }}
- */
-export function buildActionsSchema (actions = [], options = {}) {
-  const capabilities = buildCapabilities(
-    {
-      actions,
-      tasks: options.tasks || actions.flatMap(a => {
-        try {
-          return [{ id: taskIdFromActionId(a.id) }]
-        } catch {
-          return []
-        }
-      }),
-      schemas: options.schemas || [],
-      taskCatalog: options.taskCatalog || [],
-      taskGraphEdges: options.taskGraphEdges || [],
-    },
-    { generatedAt: options.generatedAt },
-  )
-  return capabilitiesToActionsSchema(capabilities, actions)
-}
-
-export {
-  buildCapabilities,
-  buildCapabilitiesGraph,
-  capabilitiesTaskTopologyResource,
-  capabilitiesToActionsSchema,
-  projectTaskForCapabilities,
-  TASK_TOPOLOGY_RESOURCE_URI,
-} from './build-capabilities.js'
+export * from '@ossy/manifest/build-actions-schema'

package/src/manifest/build-capabilities.js

@@ -1,190 +1 @@
-import { actionIdToToolName, humanizeActionId } from './action-id-to-tool-name.js'
-import { buildActionInputSchema } from './build-action-input-schema.js'
-import { taskIdFromActionId } from '@ossy/schema'
-
-const MCP_ACCESS = new Set(['workspace', 'public'])
-
-/** MCP resource URI for read-only task topology (tasks + graph edges). */
-export const TASK_TOPOLOGY_RESOURCE_URI = 'ossy://capabilities/task-topology'
-
-/**
- * @param {object} task
- */
-export function projectTaskForCapabilities (task) {
-  return {
-    id: task.id,
-    package: task.package ?? null,
-    moduleId: task.moduleId ?? null,
-    triggers: task.triggers ?? [],
-    schedule: task.schedule ?? null,
-    inputSchemaIds: task.inputSchemaIds ?? [],
-    actionIds: task.actionIds ?? [],
-    primaryActionId: task.primaryActionId ?? null,
-    outputs: task.outputs ?? [],
-  }
-}
-
-/**
- * Structured trigger → task edges for agent planning (ADR 0011).
- *
- * @param {object[]} taskCatalog
- */
-export function buildCapabilitiesGraph (taskCatalog = []) {
-  /** @type {Array<{ kind: string, from: object, to: { taskId: string }, label?: string }>} */
-  const edges = []
-
-  for (const task of taskCatalog) {
-    for (const trigger of task.triggers ?? []) {
-      if (trigger.kind === 'on_action' && trigger.action) {
-        edges.push({
-          kind: 'on_action',
-          from: { kind: 'action', actionId: trigger.action },
-          to: { taskId: task.id },
-          label: trigger.action,
-        })
-      }
-      if (trigger.kind === 'on_event' && trigger.type) {
-        edges.push({
-          kind: 'on_event',
-          from: {
-            kind: 'trigger',
-            type: trigger.type,
-            ...(trigger.event ? { event: trigger.event } : {}),
-          },
-          to: { taskId: task.id },
-          label: [trigger.type, trigger.event].filter(Boolean).join(' · '),
-        })
-      }
-      if (trigger.kind === 'on_schedule' && trigger.schedule) {
-        edges.push({
-          kind: 'on_schedule',
-          from: { kind: 'schedule', schedule: trigger.schedule },
-          to: { taskId: task.id },
-          label: trigger.schedule,
-        })
-      }
-    }
-    if (task.primaryActionId) {
-      edges.push({
-        kind: 'primary',
-        from: { kind: 'action', actionId: task.primaryActionId },
-        to: { taskId: task.id },
-        label: 'invoke',
-      })
-    }
-  }
-
-  return { edges }
-}
-
-/**
- * Build agent capabilities (MCP tools + resource template catalog) from manifest data.
- *
- * @param {{
- *   actions?: Array<{ id: string, access?: string, package?: string }>,
- *   tasks?: Array<{ id: string }>,
- *   schemas?: Array<object>,
- *   taskCatalog?: object[],
- *   taskGraphEdges?: object[],
- * }} manifest
- * @param {{ generatedAt?: string }} [options]
- */
-export function buildCapabilities (manifest, options = {}) {
-  const actions = manifest.actions || []
-  const tasks = manifest.tasks || []
-  const schemas = manifest.schemas || []
-  const taskCatalog = manifest.taskCatalog || []
-  const taskIds = new Set(tasks.map(t => t.id))
-
-  const tools = actions
-    .filter(action => {
-      try {
-        return taskIds.has(taskIdFromActionId(action.id))
-      } catch {
-        return false
-      }
-    })
-    .filter(action => MCP_ACCESS.has(action.access || 'authenticated'))
-    .map(action => ({
-      actionId: action.id,
-      name: actionIdToToolName(action.id),
-      title: humanizeActionId(action.id),
-      description: `Invoke ${action.id}`,
-      access: action.access || 'authenticated',
-      package: action.package,
-      channels: ['sdk', 'api', 'mcp'],
-      inputSchema: buildActionInputSchema(action.id, { schemas }),
-    }))
-    .sort((a, b) => a.actionId.localeCompare(b.actionId))
-
-  const projectedTasks = taskCatalog.map(projectTaskForCapabilities)
-
-  return {
-    version: 2,
-    generatedAt: options.generatedAt || new Date().toISOString(),
-    tools,
-    schemas: schemas.map(t => ({
-      id: t.id,
-      name: t.name,
-      package: t.package,
-      fields: t.fields,
-    })),
-    tasks: projectedTasks,
-    graph: buildCapabilitiesGraph(taskCatalog),
-    /** Legacy string-edge projection kept for UI parity — prefer `graph.edges`. */
-    taskGraphEdges: manifest.taskGraphEdges ?? [],
-  }
-}
-
-/**
- * Payload exposed via MCP resource {@link TASK_TOPOLOGY_RESOURCE_URI}.
- *
- * @param {ReturnType<typeof buildCapabilities>} capabilities
- */
-export function capabilitiesTaskTopologyResource (capabilities) {
-  return {
-    version: capabilities.version,
-    generatedAt: capabilities.generatedAt,
-    tasks: capabilities.tasks ?? [],
-    graph: capabilities.graph ?? { edges: [] },
-  }
-}
-
-/**
- * Legacy actions.schema.json shape for package detail / docs.
- *
- * @param {ReturnType<typeof buildCapabilities>} capabilities
- * @param {Array<{ id: string, access?: string, package?: string }>} [allActions]
- */
-export function capabilitiesToActionsSchema (capabilities, allActions) {
-  const toolById = Object.fromEntries(capabilities.tools.map(t => [t.actionId, t]))
-  const actions = (allActions || capabilities.tools.map(t => ({
-    id: t.actionId,
-    access: t.access,
-    package: t.package,
-  })))
-
-  return {
-    version: capabilities.version,
-    generatedAt: capabilities.generatedAt,
-    actions: actions.map(action => {
-      const tool = toolById[action.id]
-      const inputSchema = tool?.inputSchema
-        ?? buildActionInputSchema(action.id, {
-          schemas: capabilities.schemas,
-        })
-      const hasKnownEnvelope = inputSchema?.properties && !inputSchema.properties.payload
-
-      return {
-        id: action.id,
-        access: action.access ?? 'authenticated',
-        package: action.package,
-        channels: tool ? tool.channels : ['sdk', 'api'],
-        ...(tool?.title ? { title: tool.title } : {}),
-        ...(tool?.description ? { description: tool.description } : {}),
-        ...(tool?.name ? { mcpTool: tool.name } : {}),
-        ...(hasKnownEnvelope ? { inputSchema } : {}),
-      }
-    }).sort((a, b) => a.id.localeCompare(b.id)),
-  }
-}
+export * from '@ossy/manifest/build-capabilities'

package/src/manifest/build-manifest-summary.js

@@ -1,121 +1 @@
-/**
- * @param {string} packageName npm package name (e.g. `@ossy/booking`).
- * @returns {string} URL slug (e.g. `booking`).
- */
-export function packageNameToSlug (packageName) {
-  const slash = packageName.indexOf('/')
-  return slash === -1 ? packageName : packageName.slice(slash + 1)
-}
-
-/**
- * @param {string} slug URL slug (e.g. `booking`).
- * @returns {string} Scoped package name (e.g. `@ossy/booking`).
- */
-export function slugToPackageName (slug) {
-  return `@ossy/${slug}`
-}
-
-/**
- * @param {object} manifest Loaded manifest from `@ossy/platform` `loadManifest`.
- * @returns {{ packages: Array<object> }} Grouped, JSON-serializable package summary.
- */
-export function buildManifestSummary (manifest) {
-  /** @type {Map<string, object>} */
-  const groups = new Map()
-
-  const ensure = (pkg) => {
-    if (!groups.has(pkg)) {
-      groups.set(pkg, {
-        package: pkg,
-        slug: packageNameToSlug(pkg),
-        pages: [],
-        apis: [],
-        actions: [],
-        components: [],
-        schemas: [],
-        tasks: [],
-        integrations: [],
-        emails: [],
-        aggregates: [],
-      })
-    }
-    return groups.get(pkg)
-  }
-
-  const add = (pkg, key, item) => {
-    ensure(pkg || '@ossy/app')[key].push(item)
-  }
-
-  for (const page of manifest.pages || []) {
-    add(page.package, 'pages', {
-      id: page.id,
-      path: page.path,
-      ...(page.title ? { title: page.title } : {}),
-    })
-  }
-
-  for (const api of manifest.apis || []) {
-    add(api.package, 'apis', { id: api.id, path: api.path })
-  }
-
-  for (const action of manifest.actions || []) {
-    add(action.package, 'actions', {
-      id: action.id,
-      ...(action.access ? { access: action.access } : {}),
-    })
-  }
-
-  for (const component of manifest.components || []) {
-    add(component.package, 'components', { id: component.id })
-  }
-
-  for (const template of manifest.schemas || []) {
-    add(template.package, 'schemas', {
-      id: template.id,
-      ...(template.title ? { title: template.title } : {}),
-    })
-  }
-
-  for (const task of manifest.taskCatalog || manifest.tasks || []) {
-    add(task.package, 'tasks', {
-      id: task.id,
-      ...(task.moduleId ? { moduleId: task.moduleId } : {}),
-      ...(task.triggers ? { triggers: task.triggers } : {}),
-      ...(task.inputSchemaIds ? { inputSchemaIds: task.inputSchemaIds } : {}),
-      ...(task.primaryActionId ? { primaryActionId: task.primaryActionId } : {}),
-    })
-  }
-
-  for (const integration of manifest.integrations || []) {
-    add(integration.package, 'integrations', {
-      id: integration.id,
-      ...(integration.credentials?.length ? { credentials: integration.credentials } : {}),
-    })
-  }
-
-  for (const email of manifest.emails || []) {
-    add(email.package, 'emails', { id: email.id })
-  }
-
-  for (const aggregate of manifest.aggregates || []) {
-    add(aggregate.package, 'aggregates', { id: aggregate.id })
-  }
-
-  const packages = Array.from(groups.values())
-    .sort((a, b) => a.package.localeCompare(b.package))
-
-  for (const pkg of packages) {
-    for (const key of Object.keys(pkg)) {
-      if (Array.isArray(pkg[key])) {
-        pkg[key].sort((a, b) => a.id.localeCompare(b.id))
-      }
-    }
-  }
-
-  const definitions =
-    manifest.definitions && typeof manifest.definitions === 'object' && !Array.isArray(manifest.definitions)
-      ? manifest.definitions
-      : {}
-
-  return { packages, definitions }
-}
+export * from '@ossy/manifest/build-manifest-summary'

package/src/manifest/discover-package-definitions.js

@@ -1,100 +1 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-import { packageNameToSlug } from './build-manifest-summary.js'
-import { serializePackageDefinition } from './serialize-package-definition.js'
-
-/**
- * @param {string} projectRoot
- * @returns {string[]}
- */
-function collectNodeModulesDirs (projectRoot) {
-  const dirs = []
-  let current = projectRoot
-  while (true) {
-    const nm = path.join(current, 'node_modules')
-    if (fs.existsSync(nm) && fs.statSync(nm).isDirectory()) dirs.push(nm)
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return dirs
-}
-
-/**
- * Load `Definition.js` from disk only — never import the package main entry,
- * which may pull CLI side effects (e.g. `@ossy/cli` runs on import).
- *
- * @param {string} pkgDir
- * @param {object} pkg
- * @returns {Promise<object | null>}
- */
-async function loadPackageDefinition (pkgDir, pkg) {
-  if (!pkg.ossy?.src) return null
-
-  const defPath = path.join(pkgDir, pkg.ossy.src, 'Definition.js')
-  if (!fs.existsSync(defPath)) return null
-
-  try {
-    const mod = await import(pathToFileURL(defPath).href + `?t=${Date.now()}`)
-    if (mod?.Definition && typeof mod.Definition === 'object') {
-      return mod.Definition
-    }
-  } catch {
-    // skip packages without a readable Definition
-  }
-
-  return null
-}
-
-/**
- * Discover `Definition.js` from installed `@ossy/*` packages.
- *
- * @param {string} projectRoot Absolute path to the consuming app root.
- * @returns {Promise<Record<string, object>>} Map keyed by package slug.
- */
-export async function discoverPackageDefinitions (projectRoot) {
-  const nmDirs = collectNodeModulesDirs(projectRoot)
-  /** @type {Record<string, object>} */
-  const definitions = {}
-  const seen = new Set()
-
-  const tryPackageDir = async (pkgDir) => {
-    const real = fs.realpathSync(pkgDir)
-    if (seen.has(real)) return
-    seen.add(real)
-
-    const pkgJsonPath = path.join(pkgDir, 'package.json')
-    if (!fs.existsSync(pkgJsonPath)) return
-
-    let pkg
-    try {
-      pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'))
-    } catch {
-      return
-    }
-
-    const name = typeof pkg.name === 'string' ? pkg.name.trim() : ''
-    if (!name.startsWith('@ossy/')) return
-
-    const slug = packageNameToSlug(name)
-    if (!slug || definitions[slug]) return
-
-    const raw = await loadPackageDefinition(real, pkg)
-    const serialized = serializePackageDefinition(raw)
-    if (serialized) definitions[slug] = serialized
-  }
-
-  for (const nmDir of nmDirs) {
-    const scopeDir = path.join(nmDir, '@ossy')
-    if (!fs.existsSync(scopeDir) || !fs.statSync(scopeDir).isDirectory()) continue
-
-    for (const entry of fs.readdirSync(scopeDir, { withFileTypes: true })) {
-      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
-      await tryPackageDir(path.join(scopeDir, entry.name))
-    }
-  }
-
-  return definitions
-}
+export * from '@ossy/manifest/discover-package-definitions'