@ossy/platform 1.39.3 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.39.3",
+  "version": "3.0.2",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -44,16 +44,17 @@
     "@aws-sdk/util-create-request": "^3.972.26",
     "@aws-sdk/util-format-url": "^3.972.17",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@ossy/app": "^1.40.3",
-    "@ossy/event-store": "^1.8.3",
-    "@ossy/locale": "^1.40.3",
-    "@ossy/observability": "^1.8.3",
-    "@ossy/policies": "^1.13.3",
-    "@ossy/schema": "^1.0.1",
-    "@ossy/sdk": "^1.40.3",
-    "@ossy/tokens": "^1.13.3",
-    "@ossy/users": "^1.13.3",
-    "@ossy/workspaces": "^1.17.3",
+    "@ossy/config": "^3.0.2",
+    "@ossy/event-store": "^3.0.2",
+    "@ossy/locale": "^3.0.2",
+    "@ossy/manifest": "^3.0.2",
+    "@ossy/observability": "^3.0.2",
+    "@ossy/policies": "^3.0.2",
+    "@ossy/schema": "^3.0.2",
+    "@ossy/sdk": "^3.0.2",
+    "@ossy/tokens": "^3.0.2",
+    "@ossy/users": "^3.0.2",
+    "@ossy/workspaces": "^3.0.2",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -73,5 +74,5 @@
     "src",
     "Dockerfile"
   ],
-  "gitHead": "a0d89185a17f8de8ce328c3a648c108ff1d61d8f"
+  "gitHead": "f0a8af3c370bbaffe4f7388c14f9345a5c6c56e5"
 }

package/src/Definition.js

@@ -3,6 +3,6 @@ export const Definition = {
   title: 'Platform',
   description: 'Deployment platform configuration aligned with deployment-tools S3 platform-config.json.',
   icon: 'controller',
-  statuses: ['beta'],
+  status: ['beta'],
   entitlementRequired: false,
 }

package/src/PlatformShell.jsx

@@ -25,12 +25,12 @@ import { ComponentSlotsProvider, Slot } from '@ossy/design-system'
 export function PlatformShell({ slots = {}, children }) {
   return (
     <ComponentSlotsProvider slots={slots}>
-      <Slot name="app:system-messages" />
-      <Slot name="app:header" />
-      <Slot name="app:sidebar" />
-      <Slot name="app:toolbar" />
+      <Slot view="app:system-messages" />
+      <Slot view="app:header" />
+      <Slot view="app:sidebar" />
+      <Slot view="app:toolbar" />
       {children}
-      <Slot name="app:notifications" />
+      <Slot view="app:notifications" />
     </ComponentSlotsProvider>
   )
 }

package/src/accept-invitation.api.js

@@ -0,0 +1,46 @@
+import {
+  ActionService,
+  mergeUserAppSettingsCookie,
+  setAuthCookie,
+} from '@ossy/platform'
+
+export const metadata = {
+  id: 'users.accept-invitation',
+  path: '/api/v0/users/accept-invitation',
+  action: '@ossy/workspaces/actions/accept-invitation',
+  method: 'GET',
+  query: ['token', 'workspaceId', 'redirect'],
+}
+
+export default async function handle (req, res) {
+  if (req.method !== 'GET') {
+    res.setHeader('Allow', 'GET')
+    res.status(405).json({ error: 'Method Not Allowed' })
+    return
+  }
+
+  try {
+    const { authToken, workspaceId } = await ActionService.invoke('@ossy/workspaces/actions/accept-invitation', {
+      payload: {
+        token: req.query.token,
+        workspaceId: req.query.workspaceId,
+      },
+      req,
+    })
+
+    setAuthCookie(res, authToken)
+    if (workspaceId) {
+      mergeUserAppSettingsCookie(req, res, { workspaceId })
+    }
+
+    const redirect = req.query.redirect
+    if (redirect && typeof redirect === 'string') {
+      res.redirect(302, redirect)
+      return
+    }
+
+    res.status(200).json('')
+  } catch (err) {
+    res.status(err.status || 401).json('')
+  }
+}

package/src/actions/action.service.js

@@ -62,7 +62,7 @@ export const ActionService = {
    * Invoke an action by id — records audit, runs the derived primary task, dispatches on_action follow-ups.
    *
    * @param {string} id
-   * @param {{ payload?: unknown, sdk?: unknown, log?: unknown, integrations?: unknown, req?: unknown }} context
+   * @param {{ payload?: unknown, sdk?: unknown, log?: unknown, integrations?: unknown, req?: unknown, signal?: AbortSignal }} context
    * @returns {Promise<unknown>}
    */
   async invoke (id, context = {}) {
@@ -92,6 +92,11 @@ export const ActionService = {
 
     try {
       const result = await TaskService.invoke(taskId, invokeContext)
+      if (context.signal?.aborted) {
+        throw context.signal.reason instanceof Error
+          ? context.signal.reason
+          : new Error(`[ActionService] Action aborted: "${id}"`)
+      }
       const taskRunId = invokeContext.audit?.taskRunId ?? null
 
       if (!skipAudit) {

package/src/audit/action-invocation-service.js

@@ -3,7 +3,6 @@ import { Aggregate } from '@ossy/event-store'
 import { createLogger } from '@ossy/observability'
 import { taskIdFromActionId } from '@ossy/schema'
 import { ActionInvocation } from './action-invocation.aggregate.js'
-import { PlatformSchema } from '../schema-ids.js'
 import { MeteringService } from '../metering/metering-service.js'
 import { detectChannel } from './detect-channel.js'
 import {
@@ -42,7 +41,7 @@ export const ActionInvocationService = {
     try {
       await Aggregate.Of(ActionInvocation, {
         resourceId: invocationId,
-        type: PlatformSchema.actionInvocation,
+        type: '@ossy/platform/schema/action-invocation',
         event: 'Invoked',
         createdBy: actorId ?? undefined,
         payload: {

package/src/audit/action-invocation.aggregate.js

@@ -1,12 +1,10 @@
-import { PlatformSchema } from '../schema-ids.js'
-
 /**
  * ADR 0008 entity — audit record for each action invocation (POST /actions, MCP, SDK).
  */
 export class ActionInvocation {
 
   static kind = 'entity'
-  static SchemaId = PlatformSchema.actionInvocation
+  static SchemaId = '@ossy/platform/schema/action-invocation'
   static AggregateType = 'ActionInvocation'
 
   static View (events, state = {}) {

package/src/audit/task-run-list.aggregate.js

@@ -1,5 +1,3 @@
-import { PlatformSchema } from '../schema-ids.js'
-
 /**
  * ADR 0008 projection — workspace-scoped task run list for UI and billing queries.
  */
@@ -9,9 +7,9 @@ export class TaskRunListProjection {
   static ProjectionId = '@ossy/platform/data/task-run-list'
 
   static sources = [
-    { type: PlatformSchema.taskRun, event: 'Started' },
-    { type: PlatformSchema.taskRun, event: 'Completed' },
-    { type: PlatformSchema.taskRun, event: 'Failed' },
+    { type: '@ossy/platform/schema/task-run', event: 'Started' },
+    { type: '@ossy/platform/schema/task-run', event: 'Completed' },
+    { type: '@ossy/platform/schema/task-run', event: 'Failed' },
   ]
 
   static scopeFromEvent (event) {

package/src/audit/task-run-service.js

@@ -2,7 +2,6 @@ import { nanoid } from 'nanoid'
 import { Aggregate } from '@ossy/event-store'
 import { createLogger, metrics } from '@ossy/observability'
 import { TaskRun } from './task-run.aggregate.js'
-import { PlatformSchema } from '../schema-ids.js'
 import { MeteringService } from '../metering/metering-service.js'
 import { detectChannel } from './detect-channel.js'
 import {
@@ -12,9 +11,18 @@ import {
   summarizeError,
   summarizeResult,
 } from './audit-helpers.js'
+import { rejectOnAbort } from '../request-diagnostics.js'
 
 const log = createLogger('platform/task-run')
 
+function assertNotAborted (context) {
+  if (context.signal?.aborted) {
+    throw context.signal.reason instanceof Error
+      ? context.signal.reason
+      : new Error('Operation aborted')
+  }
+}
+
 function recordTaskMetrics (taskId, durationMs) {
   try { metrics.timing('task.duration', durationMs, { task: taskId }) } catch {}
   try { metrics.increment('task.run', { task: taskId }) } catch {}
@@ -49,6 +57,10 @@ export const TaskRunService = {
     } = opts
 
     if (audit === false) {
+      assertNotAborted(context)
+      if (context.signal) {
+        return Promise.race([handler(context), rejectOnAbort(context.signal)])
+      }
       return handler(context)
     }
 
@@ -72,7 +84,10 @@ export const TaskRunService = {
     })
 
     try {
-      const result = await handler(context)
+      assertNotAborted(context)
+      const result = context.signal
+        ? await Promise.race([handler(context), rejectOnAbort(context.signal)])
+        : await handler(context)
       const durationMs = Date.now() - startMs
       await TaskRunService._appendCompleted({
         runId,
@@ -145,7 +160,7 @@ export const TaskRunService = {
     try {
       await Aggregate.Of(TaskRun, {
         resourceId: runId,
-        type: PlatformSchema.taskRun,
+        type: '@ossy/platform/schema/task-run',
         event: 'Started',
         createdBy: actorId ?? undefined,
         payload: {

package/src/audit/task-run.aggregate.js

@@ -1,12 +1,10 @@
-import { PlatformSchema } from '../schema-ids.js'
-
 /**
  * ADR 0008 entity — one stream per task execution (sync invoke, changestream, cron, on_action).
  */
 export class TaskRun {
 
   static kind = 'entity'
-  static SchemaId = PlatformSchema.taskRun
+  static SchemaId = '@ossy/platform/schema/task-run'
   static AggregateType = 'TaskRun'
 
   static View (events, state = {}) {

package/src/config.service.js

@@ -1,48 +1 @@
-/**
- * API Configuration
- * @class
- */
-export class ConfigService {
-
-  static Port = process.env.BE_PORT || 3000
-  static Domain = process.env.DOMAIN || `localhost:${ConfigService.Port}`
-  static WebClientDomain = process.env.WEB_CLIENT_DOMAIN || `http://localhost:3000`
-  static MongoUrl = process.env.DB_URL || 'mongodb://mongodb:27017/'
-  static DbName = process.env.DB_NAME || 'test'
-  static TokenSecret = process.env.TOKEN_SECRET || 'testsecret2'
-  static TokenValidity = process.env.TOKEN_VALIDITY || 60 * 60 * 24 * 14
-  static LimitedAccessCode = process.env.LIMITED_ACCESS_CODE || 'test'
-  static BuildEnvironment = process.env.BUILD_ENVIRONMENT
-  static BotUserEmail = process.env.BOT_USER_EMAIL || 'ossybot@ossy.se'
-  static BotUserId = process.env.BOT_USER_ID || 'Mil5qAL7jDFCTyuKD_BKb'
-  /** Set on `req.userId` when there is no valid session; role checks can treat this as unauthenticated. */
-  static AnonymousUserId = process.env.ANONYMOUS_USER_ID || 'anonymous'
-  static MediaRepository = process.env.MEDIA_REPOSITORY
-  static MediaCdnDomainName = process.env.MEDIA_CDN_DOMAIN_NAME
-  static awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID
-  static awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
-  static SesRegion = process.env.SES_REGION || 'eu-north-1'
-  static Debug = process.env.DEBUG
-
-  /**
-   * Derives the web client base URL from the incoming request's Origin or Referer
-   * header so that email links point back to whichever domain the user came from
-   * (e.g. http://ossy.local, http://localhost:3002).  Falls back to the
-   * WEB_CLIENT_DOMAIN env var / default when no header is present.
-   */
-  static getWebClientBaseUrl(req) {
-    const origin = req?.headers?.origin
-    if (origin && origin !== 'null') return origin
-
-    const referer = req?.headers?.referer
-    if (referer) {
-      try {
-        const { origin: refOrigin } = new URL(referer)
-        if (refOrigin && refOrigin !== 'null') return refOrigin
-      } catch {}
-    }
-
-    return ConfigService.WebClientDomain
-  }
-
-}
+export { ConfigService } from '@ossy/config'

package/src/directory.schema.js

@@ -1,7 +1,5 @@
-import { PlatformSchema } from './schema-ids.js'
-
 export default {
-  id: PlatformSchema.directory,
+  id: '@ossy/platform/schema/directory',
   name: 'Directory',
   categoryName: 'Platform',
   icon: 'folder',

package/src/file.schema.js

@@ -1,7 +1,5 @@
-import { PlatformSchema } from './schema-ids.js'
-
 export default {
-  id: PlatformSchema.file,
+  id: '@ossy/platform/schema/file',
   name: 'File',
   categoryName: 'Platform',
   icon: 'file',

package/src/index.js

@@ -4,7 +4,6 @@ export { ChangeStream } from './tasks/change-stream.js'
 export { registerSchema, getSystemSchemas } from './resources/schema.registry.js'
 export { getPlatformSchema, initPlatformSchema, createSchemaEngine, schemaForWorkspace } from './resources/schema.service.js'
 export { validateSchemasForImport, ALLOWED_FIELD_TYPES, normalizeFieldType, resolveFieldDef } from './resources/schema.validation.js'
-export { PlatformSchema } from './schema-ids.js'
 export { IntegrationService } from './integration.service.js'
 export { ConfigService } from './config.service.js'
 export { ActionService } from './actions/action.service.js'

package/src/mcp/create-ossy-mcp-server.js

@@ -3,7 +3,7 @@ import { jsonSchemaToZodShape } from './json-schema-to-zod.js'
 import {
   TASK_TOPOLOGY_RESOURCE_URI,
   capabilitiesTaskTopologyResource,
-} from '@ossy/app/manifest/build-capabilities'
+} from '@ossy/manifest/build-capabilities'
 
 /**
  * @param {{

package/src/mcp/mount-platform-mcp.js

@@ -1,4 +1,4 @@
-import { buildCapabilities } from '@ossy/app/manifest/build-capabilities'
+import { buildCapabilities } from '@ossy/manifest/build-capabilities'
 import { mountOssyMcp } from './mount-ossy-mcp.js'
 import { uploadFileToolHandler, UPLOAD_FILE_TOOL } from './upload-file-tool.js'
 import { ActionService } from '../actions/action.service.js'

package/src/metering/metering-service.js

@@ -1,7 +1,6 @@
 import { nanoid } from 'nanoid'
 import { EventStore } from '@ossy/event-store'
 import { createLogger, metrics } from '@ossy/observability'
-import { PlatformSchema } from '../schema-ids.js'
 import { moduleIdFromTaskId } from '../audit/audit-helpers.js'
 
 const log = createLogger('platform/metering')
@@ -73,7 +72,7 @@ export const MeteringService = {
     try {
       await EventStore.AppendResourceEvent({
         id: nanoid(),
-        type: PlatformSchema.meterEvent,
+        type: '@ossy/platform/schema/meter-event',
         resourceId: nanoid(),
         event: 'Recorded',
         version: 1,

package/src/push/mount-push-sse.js

@@ -5,6 +5,46 @@ const log = createLogger('@ossy/platform')
 
 const HEARTBEAT_MS = 25_000
 
+/** @type {Map<string, number>} */
+const activeConnectionsByWorkspace = new Map()
+
+/** @type {Set<{ res: import('express').Response, heartbeat: ReturnType<typeof setInterval>, unsubscribe: () => void, workspaceId: string }>} */
+const activeConnections = new Set()
+
+function trackConnection (workspaceId, delta) {
+  const next = Math.max(0, (activeConnectionsByWorkspace.get(workspaceId) ?? 0) + delta)
+  if (next === 0) {
+    activeConnectionsByWorkspace.delete(workspaceId)
+  } else {
+    activeConnectionsByWorkspace.set(workspaceId, next)
+  }
+  return next
+}
+
+function releaseConnection (connection) {
+  if (!activeConnections.delete(connection)) return
+
+  clearInterval(connection.heartbeat)
+  connection.unsubscribe()
+  const remaining = trackConnection(connection.workspaceId, -1)
+  log.debug('[push] SSE closed', {
+    workspaceId: connection.workspaceId,
+    activeForWorkspace: remaining,
+  })
+}
+
+/**
+ * Tear down all open SSE connections so HTTP server shutdown is not blocked.
+ */
+export function closePushSseConnections () {
+  for (const connection of [...activeConnections]) {
+    releaseConnection(connection)
+    if (!connection.res.writableEnded) {
+      connection.res.end()
+    }
+  }
+}
+
 /**
  * ADR 0008 §9 — workspace-scoped SSE invalidation bus.
  *
@@ -30,14 +70,22 @@ export function mountPushSse (app) {
     send({ kind: 'connected', scope: { workspaceId } })
 
     const unsubscribe = PushInvalidation.subscribe(workspaceId, send)
+    const activeForWorkspace = trackConnection(workspaceId, 1)
+    log.debug('[push] SSE opened', {
+      workspaceId,
+      activeForWorkspace,
+      userId: req.userId,
+    })
+
     const heartbeat = setInterval(() => {
       res.write(': heartbeat\n\n')
     }, HEARTBEAT_MS)
 
+    const connection = { res, heartbeat, unsubscribe, workspaceId }
+    activeConnections.add(connection)
+
     req.on('close', () => {
-      clearInterval(heartbeat)
-      unsubscribe()
-      log.debug(`[push] SSE closed for workspace ${workspaceId}`)
+      releaseConnection(connection)
     })
   })
 }

package/src/request-diagnostics.js

@@ -0,0 +1,144 @@
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('@ossy/platform/request-diagnostics')
+
+export class OperationTimeoutError extends Error {
+  constructor (label, timeoutMs) {
+    super(`Operation timed out after ${timeoutMs}ms: ${label}`)
+    this.name = 'OperationTimeoutError'
+    this.label = label
+    this.timeoutMs = timeoutMs
+  }
+}
+
+export function resolveTimeoutMs (envKey, fallback) {
+  const raw = process.env[envKey]
+  const parsed = Number.parseInt(String(raw ?? ''), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
+/**
+ * Reject when `promise` does not settle within `timeoutMs`.
+ * Pass `timeoutMs <= 0` to disable (returns `promise` unchanged).
+ *
+ * When `abortController` is supplied, aborts its signal on timeout so callers
+ * can propagate cancellation into long-running work.
+ *
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {number} timeoutMs
+ * @param {string} label
+ * @param {{ abortController?: AbortController }} [options]
+ * @returns {Promise<T>}
+ */
+export function withTimeout (promise, timeoutMs, label, options = {}) {
+  if (!timeoutMs || timeoutMs <= 0) return promise
+
+  const { abortController } = options
+  let timer
+
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const err = new OperationTimeoutError(label, timeoutMs)
+      abortController?.abort(err)
+      reject(err)
+    }, timeoutMs)
+  })
+
+  const abortPromise = abortController
+    ? new Promise((_, reject) => {
+        const { signal } = abortController
+        if (signal.aborted) {
+          reject(signal.reason ?? new OperationTimeoutError(label, timeoutMs))
+          return
+        }
+        signal.addEventListener('abort', () => {
+          reject(signal.reason ?? new OperationTimeoutError(label, timeoutMs))
+        }, { once: true })
+      })
+    : null
+
+  const races = abortPromise ? [promise, timeoutPromise, abortPromise] : [promise, timeoutPromise]
+
+  return Promise.race(races).finally(() => {
+    clearTimeout(timer)
+  })
+}
+
+/**
+ * Reject when a signal aborts (used to race cooperative task handlers).
+ *
+ * @param {AbortSignal} signal
+ * @returns {Promise<never>}
+ */
+export function rejectOnAbort (signal) {
+  return new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason ?? new Error('Operation aborted'))
+      return
+    }
+    signal.addEventListener('abort', () => {
+      reject(signal.reason ?? new Error('Operation aborted'))
+    }, { once: true })
+  })
+}
+
+/**
+ * Log when an operation exceeds the slow threshold.
+ *
+ * @param {string} label
+ * @param {{ log?: import('@ossy/observability').Logger, warnThresholdMs?: number }} [options]
+ */
+export function createTimedOperation (label, options = {}) {
+  const logger = options.log ?? log
+  const warnThresholdMs = options.warnThresholdMs
+    ?? resolveTimeoutMs('OSSY_REQUEST_SLOW_MS', 5000)
+  const start = performance.now()
+
+  return {
+    finish (detail) {
+      const elapsedMs = Math.round(performance.now() - start)
+      const payload = { label, elapsedMs, ...(detail ?? {}) }
+      if (elapsedMs >= warnThresholdMs) {
+        logger.warn('[slow-operation]', payload)
+      } else {
+        logger.debug('[timing]', payload)
+      }
+      return elapsedMs
+    },
+  }
+}
+
+/**
+ * Express middleware — logs requests that exceed OSSY_REQUEST_SLOW_MS (default 5s).
+ *
+ * @param {import('@ossy/observability').Logger} [logger]
+ */
+export function createSlowRequestLogger (logger = log) {
+  const slowThresholdMs = resolveTimeoutMs('OSSY_REQUEST_SLOW_MS', 5000)
+
+  return (req, res, next) => {
+    const start = performance.now()
+    const requestUrl = req.originalUrl || req.url || '/'
+
+    const onFinished = () => {
+      res.removeListener('finish', onFinished)
+      res.removeListener('close', onFinished)
+      const elapsedMs = Math.round(performance.now() - start)
+      if (elapsedMs < slowThresholdMs) return
+
+      logger.warn('[slow-request]', {
+        method: req.method,
+        url: requestUrl,
+        elapsedMs,
+        statusCode: res.statusCode,
+        userId: req.userId,
+        workspaceId: req.workspaceId,
+      })
+    }
+
+    res.on('finish', onFinished)
+    res.on('close', onFinished)
+    next()
+  }
+}

package/src/request-diagnostics.spec.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from '@jest/globals'
+import { OperationTimeoutError, rejectOnAbort, withTimeout } from './request-diagnostics.js'
+
+describe('request-diagnostics', () => {
+  it('withTimeout resolves when promise settles in time', async () => {
+    const result = await withTimeout(Promise.resolve('ok'), 100, 'fast')
+    expect(result).toBe('ok')
+  })
+
+  it('withTimeout rejects with OperationTimeoutError when promise is slow', async () => {
+    await expect(withTimeout(new Promise(() => {}), 20, 'slow-op')).rejects.toMatchObject({
+      label: 'slow-op',
+      timeoutMs: 20,
+    })
+    await expect(withTimeout(new Promise(() => {}), 20, 'slow-op')).rejects.toBeInstanceOf(OperationTimeoutError)
+  })
+
+  it('withTimeout passes through when timeout is disabled', async () => {
+    const result = await withTimeout(Promise.resolve(42), 0, 'disabled')
+    expect(result).toBe(42)
+  })
+
+  it('withTimeout aborts the supplied controller on timeout', async () => {
+    const abortController = new AbortController()
+    let aborted = false
+    abortController.signal.addEventListener('abort', () => { aborted = true })
+
+    await expect(
+      withTimeout(new Promise(() => {}), 20, 'abortable', { abortController }),
+    ).rejects.toBeInstanceOf(OperationTimeoutError)
+    expect(aborted).toBe(true)
+    expect(abortController.signal.aborted).toBe(true)
+  })
+
+  it('rejectOnAbort rejects when signal is already aborted', async () => {
+    const abortController = new AbortController()
+    abortController.abort(new Error('already gone'))
+    await expect(rejectOnAbort(abortController.signal)).rejects.toThrow(/already gone/)
+  })
+})

package/src/resources/schema.registry.js

@@ -1,26 +1 @@
-import { createLogger } from '@ossy/observability'
-
-const log = createLogger('platform')
-
-/** @type {object[]} */
-const systemSchemas = []
-
-/**
- * Register a single schema POJO (as inlined in `build/manifest.json`).
- *
- * @param {object} schema
- */
-export function registerSchema (schema) {
-  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return
-  if (typeof schema.id !== 'string' || schema.id.trim() === '') return
-  if (systemSchemas.find(s => s.id === schema.id)) return
-  systemSchemas.push(schema)
-  log.info(`[SchemaRegistry] Registered system schema: ${schema.id}`)
-}
-
-/**
- * @returns {object[]}
- */
-export function getSystemSchemas () {
-  return systemSchemas
-}
+export { registerSchema, getSystemSchemas } from '@ossy/schema'