@ossy/app 1.40.2 → 3.0.1

package/runtime/merge-shell-slots.js

@@ -0,0 +1,148 @@
+import { CONTENT_SLOT_NAME, normalizeAppSlotName } from './resolve-app-slots.js'
+
+/**
+ * @typedef {{ view?: string | null, props: Record<string, unknown> }} ShellSlotSpec
+ */
+
+/**
+ * Coerce a manifest/runtime slot value to {@link ShellSlotSpec}.
+ *
+ * @param {string | null | ShellSlotSpec | undefined} value
+ * @returns {ShellSlotSpec | undefined}
+ */
+export function coerceShellSlotSpec (value) {
+  if (value === null) return { view: null, props: {} }
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    return trimmed ? { view: trimmed, props: {} } : undefined
+  }
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const { view, props: nestedProps, ...rest } = value
+    const propBag = {
+      ...(nestedProps && typeof nestedProps === 'object' && !Array.isArray(nestedProps) ? nestedProps : {}),
+      ...rest,
+    }
+    /** @type {ShellSlotSpec} */
+    const spec = { props: propBag }
+    if (view === null) spec.view = null
+    else if (typeof view === 'string') {
+      const trimmed = view.trim()
+      if (trimmed) spec.view = trimmed
+    }
+    return spec
+  }
+  return undefined
+}
+
+/**
+ * Apply one layer onto the accumulated slot spec (layout → app → page).
+ *
+ * - `null` / `{ view: null }` → unset
+ * - string → set view, keep inherited props
+ * - `{ …props }` → shallow-merge props, keep inherited view
+ * - `{ view, …props }` → set view + merge props
+ * - `{}` → no-op
+ *
+ * @param {ShellSlotSpec | undefined} current
+ * @param {string | null | Record<string, unknown> | undefined} value
+ * @returns {ShellSlotSpec | undefined}
+ */
+export function applyShellSlotLayer (current, value) {
+  if (value === null) {
+    return { view: null, props: {} }
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (!trimmed) return current
+    return {
+      view: trimmed,
+      props: current?.props ? { ...current.props } : {},
+    }
+  }
+
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    if (Object.keys(value).length === 0) {
+      return current
+    }
+
+    const { view, props: nestedProps, ...rest } = value
+    if (view === null) {
+      return { view: null, props: {} }
+    }
+
+    const restProps = {
+      ...(nestedProps && typeof nestedProps === 'object' && !Array.isArray(nestedProps) ? nestedProps : {}),
+      ...rest,
+    }
+    const nextProps = Object.keys(restProps).length > 0
+      ? { ...(current?.props ?? {}), ...restProps }
+      : { ...(current?.props ?? {}) }
+
+    /** @type {ShellSlotSpec} */
+    const next = { props: nextProps }
+    if (view !== undefined) {
+      if (typeof view === 'string') {
+        const trimmed = view.trim()
+        if (trimmed) next.view = trimmed
+      }
+    } else if (current?.view !== undefined) {
+      next.view = current.view
+    }
+
+    return next
+  }
+
+  return current
+}
+
+/**
+ * @param {ShellSlotSpec | string | null | undefined} spec
+ * @returns {boolean}
+ */
+export function shellSlotUnset (spec) {
+  const normalized = typeof spec === 'string' || spec === null ? coerceShellSlotSpec(spec) : spec
+  return normalized?.view === null
+}
+
+/**
+ * @param {ShellSlotSpec | string | null | undefined} spec
+ * @returns {string | undefined}
+ */
+export function shellSlotViewId (spec) {
+  const normalized = typeof spec === 'string' || spec === null ? coerceShellSlotSpec(spec) : spec
+  if (!normalized || normalized.view === null) return undefined
+  return typeof normalized.view === 'string' ? normalized.view : undefined
+}
+
+/**
+ * Merge shell slot maps per ADR 0012: layout defaults → app config → page metadata.
+ * Page layer wins for both view (when set) and props.
+ *
+ * @param {Record<string, string | null | Record<string, unknown>> | null | undefined} layoutSlots
+ * @param {Record<string, string | null | Record<string, unknown>> | null | undefined} appSlots
+ * @param {Record<string, string | null | Record<string, unknown>> | null | undefined} pageSlots
+ * @returns {Record<string, ShellSlotSpec>}
+ */
+export function mergeShellSlots (layoutSlots, appSlots, pageSlots) {
+  /** @type {Record<string, ShellSlotSpec>} */
+  const merged = {}
+
+  const apply = (map) => {
+    if (!map || typeof map !== 'object' || Array.isArray(map)) return
+    Object.entries(map).forEach(([rawKey, value]) => {
+      const key = normalizeAppSlotName(rawKey)
+      if (!key || key === CONTENT_SLOT_NAME) return
+      const next = applyShellSlotLayer(merged[key], value)
+      if (next !== undefined) {
+        merged[key] = next
+      }
+    })
+  }
+
+  apply(layoutSlots)
+  apply(appSlots)
+  apply(pageSlots)
+
+  return merged
+}

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-shell-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-shell-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,19 +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: Component,
+      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 ?? {}))
 
@@ -175,12 +188,17 @@ export function createPageEntry (pageModule, options = {}) {
       loadComponents(componentEntries),
       loadLayout(layoutEntry),
     ]).then(([{ hydrateRoot }, componentsById, Layout]) => {
+      const PageContent = (slotProps = {}) => createElement(Component, { ...pageProps, ...slotProps })
       const components = resolvePageSlots({
         layoutSlots,
         componentsById,
-        pageComponent: Component,
+        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

@@ -0,0 +1,126 @@
+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. */
+export const CONTENT_SLOT_NAME = 'app:content'
+
+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.
+ *
+ * @param {string} slotName
+ * @returns {string}
+ */
+export function normalizeAppSlotName (slotName) {
+  const key = typeof slotName === 'string' ? slotName.trim() : ''
+  return BARE_APP_REGION[key] ?? key
+}
+
+/**
+ * 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 | import('./merge-shell-slots.js').ShellSlotSpec | undefined> | null | undefined} layoutSlotsMap
+ * @param {Record<string, import('react').ComponentType>} componentsById
+ * @returns {Record<string, import('react').ComponentType>}
+ */
+export function resolveAppSlots (layoutSlotsMap, componentsById) {
+  /** @type {Record<string, import('react').ComponentType>} */
+  const resolved = {}
+
+  const map = layoutSlotsMap && typeof layoutSlotsMap === 'object' ? layoutSlotsMap : {}
+  for (const [rawSlot, rawSpec] of Object.entries(map)) {
+    const slotName = normalizeAppSlotName(rawSlot)
+    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 (slotName in resolved) continue
+    if (componentsById[slotName]) {
+      resolved[slotName] = componentsById[slotName]
+      continue
+    }
+    const bare = slotName.slice(`${APP_SLOT_PREFIX}:`.length)
+    if (componentsById[bare]) resolved[slotName] = componentsById[bare]
+  }
+
+  return resolved
+}
+
+/**
+ * Full provider slot map for a page request: app chrome and page content.
+ * Feature components register at canonical ADR 0006 ids (`@ossy/…/view|form|…`).
+ *
+ * @param {{
+ *   layoutSlots?: Record<string, string | null | import('./merge-shell-slots.js').ShellSlotSpec> | null,
+ *   componentsById?: Record<string, import('react').ComponentType>,
+ *   pageComponent?: import('react').ComponentType | null,
+ * }} options
+ * @returns {Record<string, import('react').ComponentType>}
+ */
+export function resolvePageSlots ({ layoutSlots, componentsById = {}, pageComponent = null } = {}) {
+  const appSlots = resolveAppSlots(layoutSlots, componentsById)
+  /** @type {Record<string, import('react').ComponentType>} */
+  const resolved = { ...componentsById, ...appSlots }
+  if (pageComponent) {
+    resolved[CONTENT_SLOT_NAME] = pageComponent
+  }
+  return resolved
+}

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/action-id-to-tool-name.js

@@ -0,0 +1,29 @@
+/**
+ * Derive MCP tool name from platform action id.
+ *
+ * @example
+ * actionIdToToolName('@ossy/resources/actions/list') // 'ossy_resources_list'
+ *
+ * @param {string} actionId
+ * @returns {string}
+ */
+export function actionIdToToolName (actionId) {
+  const parts = actionId.split('/')
+  if (parts.length >= 4 && parts[0].startsWith('@') && parts[2] === 'actions') {
+    const provider = parts[0].slice(1)
+    return `${provider}_${parts[1]}_${parts[3]}`.replace(/-/g, '_')
+  }
+  return `ossy_${actionId.replace(/^@/, '').replace(/\//g, '_').replace(/-/g, '_')}`
+}
+
+/**
+ * @param {string} actionId
+ * @returns {string}
+ */
+export function humanizeActionId (actionId) {
+  const intent = actionId.split('/').pop() || actionId
+  return intent
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+}

package/src/manifest/build-action-input-schema.js

@@ -0,0 +1,220 @@
+import { templatesContentOneOf } from './template-to-json-schema.js'
+
+const workspaceIdProp = {
+  workspaceId: {
+    type: 'string',
+    description: 'Workspace id (defaults to request workspace header)',
+  },
+}
+
+/** @type {Record<string, (ctx: { schemas: object[] }) => object>} */
+const ENVELOPES = {
+  '@ossy/resources/actions/list': () => ({
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      location: { type: 'string', description: 'Folder path, e.g. /test/' },
+      query: { type: 'object', description: 'Optional query filters merged with location' },
+    },
+  }),
+
+  '@ossy/resources/actions/get': () => ({
+    type: 'object',
+    required: ['resourceId'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/search': () => ({
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      location: { type: 'string' },
+      name: { type: 'string' },
+      type: { type: 'string', description: 'Resource template id or mime type' },
+    },
+  }),
+
+  '@ossy/resources/actions/create': ({ schemas }) => {
+    const contentSchema = templatesContentOneOf(schemas)
+    return {
+      type: 'object',
+      required: ['location', 'name', 'type'],
+      properties: {
+        ...workspaceIdProp,
+        location: { type: 'string', description: 'Parent folder path, e.g. /test/' },
+        name: { type: 'string' },
+        type: {
+          type: 'string',
+          description: 'directory | mime type (binary) | registered resource template id',
+        },
+        size: {
+          type: 'number',
+          description: 'Byte size — required when type is a mime type (binary upload)',
+        },
+        ...(contentSchema
+          ? {
+              content: {
+                description: 'Document payload when type is a resource template id',
+                ...contentSchema,
+              },
+            }
+          : {}),
+      },
+    }
+  },
+
+  '@ossy/resources/actions/update-content': ({ schemas }) => {
+    const contentSchema = templatesContentOneOf(schemas)
+    return {
+      type: 'object',
+      required: ['resourceId', 'content'],
+      properties: {
+        ...workspaceIdProp,
+        resourceId: { type: 'string' },
+        ...(contentSchema
+          ? { content: contentSchema }
+          : { content: { type: 'object' } }),
+      },
+    }
+  },
+
+  '@ossy/resources/actions/delete': () => ({
+    type: 'object',
+    required: ['resourceId'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/upload-named-version': () => ({
+    type: 'object',
+    required: ['resourceId', 'namedVersion', 'type', 'size'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      namedVersion: { type: 'string', description: 'Version label, e.g. thumbnail' },
+      type: { type: 'string', description: 'Mime type' },
+      size: { type: 'number' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-name': () => ({
+    type: 'object',
+    required: ['resourceId', 'name'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      name: { type: 'string' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-location': () => ({
+    type: 'object',
+    required: ['resourceId', 'target'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      target: { type: 'string', description: 'Destination folder path' },
+    },
+  }),
+
+  '@ossy/resources/actions/update-access': () => ({
+    type: 'object',
+    required: ['resourceId', 'access'],
+    properties: {
+      ...workspaceIdProp,
+      resourceId: { type: 'string' },
+      access: { type: 'string', enum: ['public', 'workspace', 'restricted'] },
+    },
+  }),
+
+  '@ossy/booking/actions/get-services': () => ({
+    type: 'object',
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      includeInactive: { type: 'boolean' },
+      includeContact: { type: 'boolean' },
+    },
+  }),
+
+  '@ossy/booking/actions/get-available-slots': () => ({
+    type: 'object',
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      serviceId: { type: 'string' },
+      duration: { type: 'number', description: 'Slot duration in minutes' },
+      from: { type: 'number', description: 'Range start (Unix ms)' },
+      to: { type: 'number', description: 'Range end (Unix ms)' },
+    },
+  }),
+
+  '@ossy/booking/actions/create': () => ({
+    type: 'object',
+    required: ['startAt', 'duration', 'clientName', 'clientEmail'],
+    properties: {
+      providerSlug: { type: 'string' },
+      workspaceId: { type: 'string' },
+      serviceId: { type: 'string' },
+      startAt: { type: 'number', description: 'Slot start (Unix ms)' },
+      duration: { type: 'number', description: 'Duration in minutes' },
+      clientName: { type: 'string' },
+      clientEmail: { type: 'string', format: 'email' },
+      clientMessage: { type: 'string' },
+    },
+  }),
+
+  '@ossy/workspaces/actions/get-schemas': () => ({
+    type: 'object',
+    properties: { ...workspaceIdProp },
+  }),
+
+  '@ossy/workspaces/actions/import-schemas': () => ({
+    type: 'object',
+    required: ['schemas'],
+    properties: {
+      ...workspaceIdProp,
+      schemas: {
+        type: 'array',
+        items: { type: 'object' },
+        description: 'Workspace-imported schema definitions',
+      },
+    },
+  }),
+
+  '@ossy/users/actions/create-api-token': () => ({
+    type: 'object',
+    required: ['name', 'description'],
+    properties: {
+      name: { type: 'string' },
+      description: { type: 'string' },
+    },
+  }),
+}
+
+/**
+ * @param {string} actionId
+ * @param {{ schemas?: object[] }} [ctx]
+ * @returns {object}
+ */
+export function buildActionInputSchema (actionId, ctx = {}) {
+  const schemas = ctx.schemas || []
+  const builder = ENVELOPES[actionId]
+  if (builder) {
+    return builder({ schemas })
+  }
+
+  return {
+    type: 'object',
+    properties: {
+      ...workspaceIdProp,
+      payload: { type: 'object', description: 'Action-specific payload' },
+    },
+    additionalProperties: true,
+  }
+}

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

@@ -0,0 +1,36 @@
+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'